Client/GameTools/CHARACTERACTIONCONTROL/Creature.cpp

// Creature.cpp: implementation of the CCreature class.
//
//////////////////////////////////////////////////////////////////////

#include "Creature.h"
#include "SceneManager.h"
#include "CameraControl.h"
#include "CharacterControl.h"


//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////

#define KeyPressed( key )    HIBYTE( GetAsyncKeyState( key ) )	
//extern CCharacterControl g_CharacterData;

//char CCreature::m_strWeaponMotionSheet[MAX_WEAPONTABLE][256];
//char CCreature::m_strWeapon[MAX_WEAPONTABLE][256];

CCreature::CCreature()
{
	m_bUpperAble = TRUE;
	m_bLowerAble = TRUE;
	m_bUpperAnimating = FALSE;
	m_bLowerAnimating = FALSE;

	m_dwLowerChrAction = CA_WAIT;
	m_dwUpperChrAction = CA_WAIT;

	m_fRunFactor = 0.0f;
	m_dwAttackCombo = 0;
	m_dwSkillComboCount = 0;
	m_bSkillCombo = FALSE;
	m_fDeadTimer = -1.0f;
	m_sDamage = 0;
	m_fScale = 1.0f;
	m_fChatTimer = 0.0f;

	m_wMaxHP = 0;
	m_sCurrHP = -1;
	m_wMaxMP = 0;
	m_sCurrMP = -1;

	m_dwPartyID = 0;
	m_dwChant = 0;

	m_cSex = 1;
	m_cNation = 0;
	m_cLevel = 0;
	m_bCharDead = FALSE;
	m_bUsed = FALSE;
	m_bSitMode = FALSE;
	m_bFlying = FALSE;
	m_bFlyFirstCheck = FALSE;
	m_bStillCasting = FALSE;
	m_fFixAngle=0.0f;
	m_dwWeaponPos = 0;
	m_bNoneComboAttackMode=TRUE;
	m_bFirstPositionSend = FALSE;

	m_ChrAction.m_wAniNum = 0;
	m_ChrAction.m_wAniNumCount = 0;
	
	m_bArrowExist = false;
	m_Arrow.clear();
	m_bSlide = false;

	m_BodyEffect.clear();
	m_bBodyEffect = false;
	
	m_WeaponEffect.clear();
	m_bWeaponEffect = false;

	m_pWeaponLine = NULL;
	m_bWeaponLine = false;

	m_dwTargetId = 0xffffffff;
}

CCreature::~CCreature()
{
	for( int i=0; i < m_Arrow.size(); i++ ) {
		delete m_Arrow[i];
	}
	m_Arrow.clear();
	
	for( i=0; i < m_BodyEffect.size(); i++ ) {
		delete m_BodyEffect[i];
	}
	m_BodyEffect.clear();
	
	for( i=0; i < m_WeaponEffect.size(); i++ ) {
		delete m_WeaponEffect[i];
	}
	m_WeaponEffect.clear();
	
	if(m_pWeaponLine != NULL)
	{
		delete m_pWeaponLine;
		m_pWeaponLine = NULL;

	}

}

BOOL CCreature::SetAction(unsigned long dwUpperAni, unsigned long dwLowerAni)
{

	char strUpperAction[MAX_PATH], strLowerAction[MAX_PATH];
	BOOL bAction = FALSE;



	if(m_lpChrModel)
	{
		SetMotionString(dwUpperAni, strUpperAction);
		SetMotionString(dwLowerAni, strLowerAction);

		if(m_dwUpperChrAction != dwUpperAni)
		{
			if(IsCancelAction(1))
			{
				m_dwUpperChrAction = dwUpperAni;
				m_bUpperAnimating = FALSE;
			}
		}

		if(m_dwLowerChrAction != dwLowerAni)
		{
			if(IsCancelAction(2))
			{
				m_dwLowerChrAction = dwLowerAni;
				m_bLowerAnimating = FALSE;
			}
		}

	/*	if(m_lpChrModel->IsActionFinished(0)) { m_dwUpperChrAction = dwUpperAni; m_bUpperAble = TRUE; }
		if(m_lpChrModel->IsActionFinished(1)) { m_dwLowerChrAction = dwLowerAni; m_bLowerAble = TRUE; }
	*/
		if( ((m_dwUpperChrAction == CA_TURNPUNCH1 || m_dwUpperChrAction == CA_TURNPUNCH2 || m_dwUpperChrAction == CA_AIMEDSHOT1 || m_dwUpperChrAction == CA_AIMEDSHOT2 || m_dwUpperChrAction == CA_CASTING || m_dwUpperChrAction == CA_REST || m_dwUpperChrAction == CA_WAIT) && !m_bUpperAnimating) &&
			((m_dwLowerChrAction == CA_TURNPUNCH1 || m_dwLowerChrAction == CA_TURNPUNCH2 || m_dwLowerChrAction == CA_AIMEDSHOT1 || m_dwLowerChrAction == CA_AIMEDSHOT2 || m_dwLowerChrAction == CA_CASTING || m_dwLowerChrAction == CA_REST || m_dwLowerChrAction == CA_WAIT) && !m_bLowerAnimating))
		{
			m_dwUpperChrAction = dwUpperAni;
			m_dwLowerChrAction = dwLowerAni;
			m_lpChrModel->SetMotion(strUpperAction, 3);
			m_bUpperAnimating = TRUE;
			m_bLowerAnimating = TRUE;
			if(IsCancelAction(1)) m_bUpperAble = TRUE; else m_bUpperAble = FALSE;
			if(IsCancelAction(2)) m_bLowerAble = TRUE; else m_bLowerAble = FALSE;
			return TRUE;
		}

		if(!m_bUpperAnimating)
		{
			m_dwUpperChrAction = dwUpperAni;
			m_lpChrModel->SetMotion(strUpperAction, 1);
			m_bUpperAnimating = TRUE;
			bAction = TRUE;
			if(IsCancelAction(1)) m_bUpperAble = TRUE; else m_bUpperAble = FALSE;
	//		if(!m_bLowerAble) m_lpChrModel->SetMotionCurrentFrame(1, m_lpChrModel->GetMotionCurrentFrame(2));
		}
		if(!m_bLowerAnimating)
		{
			m_dwLowerChrAction = dwLowerAni;
			m_lpChrModel->SetMotion(strLowerAction, 2);
			m_bLowerAnimating = TRUE;
			bAction = TRUE;
			if(IsCancelAction(2)) m_bLowerAble = TRUE; else m_bLowerAble = FALSE;
	//		if(!m_bUpperAble) m_lpChrModel->SetMotionCurrentFrame(2, m_lpChrModel->GetMotionCurrentFrame(1));
		}
	} else
	{
		m_dwUpperChrAction = dwUpperAni;
		m_dwLowerChrAction = dwLowerAni;
		m_bUpperAnimating = FALSE;
		m_bLowerAnimating = FALSE;
		m_bUpperAble = TRUE;
		m_bLowerAble = TRUE;
	}

	return bAction;
}

BOOL CCreature::SetAction(char *strUpperAction, char *strLowerAction)
{
	

	unsigned long dwUpperAni, dwLowerAni;
	BOOL bAction = FALSE;

	SetMotionString(&dwUpperAni, strUpperAction);
	SetMotionString(&dwLowerAni, strLowerAction);


	if(m_lpChrModel)
	{
		if(m_dwUpperChrAction != dwUpperAni)
		{
			if(IsCancelAction(1))
			{
				m_dwUpperChrAction = dwUpperAni;
				m_bUpperAnimating = FALSE;
				if(IsCancelAction(1)) m_bUpperAble = TRUE; else m_bUpperAble = FALSE;
			}
		}

		if(m_dwLowerChrAction != dwLowerAni)
		{
			if(IsCancelAction(2))
			{
				m_dwLowerChrAction = dwLowerAni;
				m_bLowerAnimating = FALSE;
				if(IsCancelAction(2)) m_bLowerAble = TRUE; else m_bLowerAble = FALSE;
			}
		}

		if( ((m_dwUpperChrAction == CA_TURNPUNCH1 || m_dwUpperChrAction == CA_TURNPUNCH2 || m_dwUpperChrAction == CA_AIMEDSHOT1 || m_dwUpperChrAction == CA_AIMEDSHOT2 || m_dwUpperChrAction == CA_CASTING || m_dwUpperChrAction == CA_REST || m_dwUpperChrAction == CA_WAIT) && !m_bUpperAnimating) &&
			((m_dwLowerChrAction == CA_TURNPUNCH1 || m_dwLowerChrAction == CA_TURNPUNCH2 || m_dwLowerChrAction == CA_AIMEDSHOT1 || m_dwLowerChrAction == CA_AIMEDSHOT2 || m_dwLowerChrAction == CA_CASTING || m_dwLowerChrAction == CA_REST || m_dwLowerChrAction == CA_WAIT) && !m_bLowerAnimating))
		{
			m_lpChrModel->SetMotion(strUpperAction, 3);
			m_dwUpperChrAction = dwUpperAni;
			m_dwLowerChrAction = dwLowerAni;
			m_bUpperAnimating = TRUE;
			m_bLowerAnimating = TRUE;
			return TRUE;
		}

		if(!m_bUpperAnimating)
		{
			m_lpChrModel->SetMotion(strUpperAction, 1);
			m_dwUpperChrAction = dwUpperAni;
			m_bUpperAnimating = TRUE;
			bAction = TRUE;
	//		if(!m_bLowerAble) m_lpChrModel->SetMotionCurrentFrame(1, m_lpChrModel->GetMotionCurrentFrame(2));
		}
		if(!m_bLowerAnimating)
		{
			m_lpChrModel->SetMotion(strLowerAction, 2);
			m_dwLowerChrAction = dwLowerAni;
			m_bLowerAnimating = TRUE;
			bAction = TRUE;
	//		if(!m_bUpperAble) m_lpChrModel->SetMotionCurrentFrame(2, m_lpChrModel->GetMotionCurrentFrame(1));
		}
	} else
	{
		m_dwUpperChrAction = dwUpperAni;
		m_dwLowerChrAction = dwLowerAni;
		m_bUpperAnimating = FALSE;
		m_bLowerAnimating = FALSE;
		m_bUpperAble = TRUE;
		m_bLowerAble = TRUE;
	}

	return bAction;
}

void CCreature::SetMotionString(unsigned long dwAction, char *strAction)
{
	/// 여기서 무기에 따라 시트를 틀리게 한다.
	CollisionType CT = CSceneManager::GetCharacterCollisionType(m_lpChrModel);

	if(CT == CT_WATER)
	{
		strcpy(strAction, "SWIM");
		if(m_lpChrModel)
			m_lpChrModel->SetFixHeight(true);
			//m_lpChrModel->m_fFixHeight = 0.0f;

		return;
	}
	else
	{
		m_lpChrModel->SetFixHeight(false);
		//m_lpChrModel->m_fFixHeight = 0.0f;

	}

	switch(dwAction)
	{
		case CA_WAIT:
			strcpy(strAction, "WAIT");
			break;

		case CA_WALK:
			strcpy(strAction, "WALK");
			break;

		case CA_WALKRIGHT:
			strcpy(strAction, "WALK_RIGHT");
			break;

		case CA_WALKLEFT:
			strcpy(strAction, "WALK_LEFT");
			break;

		case CA_WALKBACK:
			strcpy(strAction, "WALK_BACK");
			break;

		case CA_RUN:
			strcpy(strAction, "RUN");
			break;

		case CA_REST:
			strcpy(strAction, "REST");
			break;

		case CA_SITDOWN:
			strcpy(strAction, "SIT_DOWN");
			break;

		case CA_STANDUP:
			strcpy(strAction, "STAND_UP");
			break;

		case CA_ATTACK:
			strcpy(strAction, "ATTACK");
			break;

		case CA_ATTACKADVANCE:
			strcpy(strAction, "ATTACK_ADVANCE");
			break;

		case CA_ATTACKLEFT:
			strcpy(strAction, "ATTACK_LEFT");
			break;

		case CA_ATTACKRIGHT:
			strcpy(strAction, "ATTACK_RIGHT");
			break;

		case CA_ATTACKRETREAT:
			strcpy(strAction, "ATTACK_RETREAT");
			break;

		case CA_ATTACK2:
			strcpy(strAction, "ATTACK2");
			break;
		case CA_ATTACK3:
			strcpy(strAction, "ATTACK3");
			break;
		case CA_ATTACK4:
			strcpy(strAction, "ATTACK4");
			break;
		case CA_ATTACK5:
			strcpy(strAction, "ATTACK5");
			break;
		case CA_ATTACK6:
			strcpy(strAction, "ATTACK6");
			break;
		case CA_FALLDOWN:
			strcpy(strAction, "FALLDOWN");
			break;
		case CA_BASH:
			strcpy(strAction, "BASH");
			break;
		case CA_COMBINATIONBLOW:
			strcpy(strAction, "COMBINATION_BLOW");
			break;
		case CA_BACKSTAB:
			strcpy(strAction, "BACKSTAB");
			break;
		case CA_FIRE1:
			strcpy(strAction, "FIRE1");
			break;
		case CA_FIRE2:
			strcpy(strAction, "FIRE2");
			break;
		case CA_SHOT:
			strcpy(strAction, "SHOT");
			break;
		case CA_JUMPSHOT:
			strcpy(strAction, "JUMP_SHOT");
			break;
		case CA_JUMP:
			strcpy(strAction, "JUMP");
			break;
		case CA_FORWARDJUMP:
			strcpy(strAction, "JUMP");
			break;
		case CA_BACKJUMP:
			strcpy(strAction, "JUMP");
			break;
		case CA_FRONTDASH:
			strcpy(strAction, "DODGE_FRONT");
			break;
		case CA_LEFTDASH:
			strcpy(strAction, "DODGE_LEFT");
			break;
		case CA_RIGHTDASH:
			strcpy(strAction, "DODGE_RIGHT");
			break;
		case CA_AIMEDSHOT1:
			strcpy(strAction, "AIMED_SHOT1");
			break;
		case CA_AIMEDSHOT2:
			strcpy(strAction, "AIMED_SHOT2");
			break;
		case CA_AIMEDSHOT3:
			strcpy(strAction, "AIMED_SHOT3");
			break;
		case CA_SWIM:
			strcpy(strAction, "SWIM");
			break;
		case CA_CASTING:
			strcpy(strAction, "CASTING");
			break;
		case CA_BACKDASH:
			strcpy(strAction, "DODGE_BACK");
			break;
		case CA_JUMPATTACK:
			strcpy(strAction, "JUMP_ATTACK");
			break;
		case CA_JUMPATTACK2:
			strcpy(strAction, "JUMP_ATTACK2");
			break;
		case CA_LAND:
			strcpy(strAction, "LAND");
			break;

		case CA_OVERBASH1:
			strcpy(strAction, "OVER_BASH1");
			break;
		case CA_OVERBASH2:
			strcpy(strAction, "OVER_BASH2");
			break;
		case CA_OVERBASH3:
			strcpy(strAction, "OVER_BASH3");
			break;
		case CA_OVERBASH4:
			strcpy(strAction, "OVER_BASH4");
			break;
		case CA_OVERBASH5:
			strcpy(strAction, "OVER_BASH5");
			break;

		case CA_POWERDRAIN:
			strcpy(strAction, "POWER_DRAIN");
			break;

		case CA_TURNPUNCH1:
			strcpy(strAction, "TURN_PUNCH1");
			break;
		case CA_TURNPUNCH2:
			strcpy(strAction, "TURN_PUNCH2");
			break;
		case CA_TURNPUNCH3:
			strcpy(strAction, "TURN_PUNCH3");
			break;

		case CA_JUMPATTACK3:
			strcpy(strAction, "JUMP_ATTACK3");
			break;

		case CA_STUN:
			strcpy(strAction, "STUN");
			break;

		case CA_ROUNDSWING:
			strcpy(strAction, "ROUND_SWING");
			break;
	}
}

void CCreature::SetMotionString(unsigned long *dwAction, char *strAction)
{
//	unsigned long dwWeapon = CCharacterControl::GetWeaponType(m_strShape[11 + m_dwWeaponPos]);

	if(!strcmp(strAction, "BASH"))
	{
		*dwAction = CA_BASH;
	} else if(!strcmp(strAction, "FIRE1"))
	{
		*dwAction = CA_FIRE1;
	} else if(!strcmp(strAction, "FIRE2"))
	{
		*dwAction = CA_FIRE2;
	} else if(!strcmp(strAction, "COMBINATION_BLOW"))
	{
		*dwAction = CA_COMBINATIONBLOW;
	} else if(!strcmp(strAction, "BACKSTAB"))
	{
		*dwAction = CA_BACKSTAB;
	} else if(!strcmp(strAction, "AIMED_SHOT1"))
	{
		*dwAction = CA_AIMEDSHOT1;
	} else if(!strcmp(strAction, "AIMED_SHOT2"))
	{
		*dwAction = CA_AIMEDSHOT2;
	} else if(!strcmp(strAction, "AIMED_SHOT3"))
	{
		*dwAction = CA_AIMEDSHOT3;
	} else if(!strcmp(strAction, "CASTING"))
	{
		*dwAction = CA_CASTING;
	} else if(!strcmp(strAction, "JUMP_ATTACK"))
	{
		*dwAction = CA_JUMPATTACK;
	} else if(!strcmp(strAction, "JUMP_ATTACK2"))
	{
		*dwAction = CA_JUMPATTACK2;
	} else if(!strcmp(strAction, "SHOT"))
	{
		*dwAction = CA_SHOT;
	} else if(!strcmp(strAction, "JUMP_SHOT"))
	{
		*dwAction = CA_JUMPSHOT;
	} else if(!strcmp(strAction, "OVER_BASH1"))
	{
		*dwAction = CA_OVERBASH1;
	} else if(!strcmp(strAction, "OVER_BASH2"))
	{
		*dwAction = CA_OVERBASH2;
	} else if(!strcmp(strAction, "OVER_BASH3"))
	{
		*dwAction = CA_OVERBASH3;
	} else if(!strcmp(strAction, "OVER_BASH4"))
	{
		*dwAction = CA_OVERBASH4;
	} else if(!strcmp(strAction, "OVER_BASH5"))
	{
		*dwAction = CA_OVERBASH5;
	} else if(!strcmp(strAction, "POWER_DRAIN"))
	{
		*dwAction = CA_POWERDRAIN;
	} else if(!strcmp(strAction, "TURN_PUNCH1"))
	{
		*dwAction = CA_TURNPUNCH1;
	} else if(!strcmp(strAction, "TURN_PUNCH2"))
	{
		*dwAction = CA_TURNPUNCH2;
	} else if(!strcmp(strAction, "TURN_PUNCH3"))
	{
		*dwAction = CA_TURNPUNCH3;
	} else if(!strcmp(strAction, "JUMP_ATTACL3"))
	{
		*dwAction = CA_JUMPATTACK3;
	} else if(!strcmp(strAction, "STUN"))
	{
		*dwAction = CA_STUN;
	} else if(!strcmp(strAction, "ROUND_SWING"))
	{
		*dwAction = CA_ROUNDSWING;
	}
}

BOOL CCreature::IsCancelAction(unsigned long dwPart)
{
	switch(dwPart)
	{
		case 1:
			if( m_dwUpperChrAction == CA_RUN || m_dwUpperChrAction == CA_WALK ||
				m_dwUpperChrAction == CA_WALKLEFT || m_dwUpperChrAction == CA_WALKRIGHT ||
				m_dwUpperChrAction == CA_WALKBACK || m_dwUpperChrAction == CA_WAIT ||
				m_dwUpperChrAction == CA_REST)/* || m_dwUpperChrAction == CA_LEFTDASH ||
				m_dwUpperChrAction == CA_RIGHTDASH)/**/
				return TRUE;
			break;

		case 2:
			if( m_dwLowerChrAction == CA_RUN || m_dwLowerChrAction == CA_WALK ||
				m_dwLowerChrAction == CA_WALKLEFT || m_dwLowerChrAction == CA_WALKRIGHT ||
				m_dwLowerChrAction == CA_WALKBACK || m_dwLowerChrAction == CA_WAIT ||
				m_dwLowerChrAction == CA_REST)
				return TRUE;
			break;

		case 3:
			if((m_dwUpperChrAction == CA_RUN || m_dwUpperChrAction == CA_WALK ||
				m_dwUpperChrAction == CA_WALKLEFT || m_dwUpperChrAction == CA_WALKRIGHT ||
				m_dwUpperChrAction == CA_WALKBACK || m_dwUpperChrAction == CA_WAIT ||
				m_dwUpperChrAction == CA_REST) && 
			   (m_dwLowerChrAction == CA_RUN || m_dwLowerChrAction == CA_WALK ||
				m_dwLowerChrAction == CA_WALKLEFT || m_dwLowerChrAction == CA_WALKRIGHT ||
				m_dwLowerChrAction == CA_WALKBACK || m_dwLowerChrAction == CA_WAIT ||
				m_dwLowerChrAction == CA_REST))
				return TRUE;
			break;
	}

	return FALSE;
}

void CCreature::InitChrAction()
{
/*	if(m_bStillCasting && m_lpChrModel->IsActionFinished(0) && m_lpChrModel->IsActionFinished(1) && !m_bCharDead)
	{
		m_bUpperAble = TRUE;
		m_bLowerAble = TRUE;
		m_bUpperAnimating = FALSE;
		m_bLowerAnimating = FALSE;

		m_dwUpperChrAction = CA_CASTING;
		m_dwLowerChrAction = CA_CASTING;
		SetAction(m_dwUpperChrAction, m_dwLowerChrAction);
		return;
	}*/

	if(m_bCharDead)
	{
		m_dwUpperChrAction = CA_FALLDOWN;
		m_dwLowerChrAction = CA_FALLDOWN;
	}

	if(m_lpChrModel->IsActionFinished(0) && !m_bCharDead)
	{
		if(GetChantFlag(26))
		{
			m_dwUpperChrAction = CA_STUN;
		} else
		{
			if(m_dwUpperChrAction == CA_SWIM)
			{
				m_dwUpperChrAction = CA_SWIM;
			} else if(m_bSitMode)
			{
				m_dwUpperChrAction = CA_REST;
			} else if(!m_bStillCasting)
			{
				m_dwUpperChrAction = CA_WAIT;
			}
		}

		m_bUpperAble = TRUE;
		m_bUpperAnimating = FALSE;
		if(m_lpChrModel)
		{
			if(GetChantFlag(27))
			{
				m_lpChrModel->SetAnimationSpeed(0.5f);
			} else
			{
				m_lpChrModel->SetAnimationSpeed(1.0f);
			}
		}
	}

	if(m_lpChrModel->IsActionFinished(1))
	{
		if(m_dwLowerChrAction == CA_FIRE1 || m_dwLowerChrAction == CA_FIRE2 || m_dwLowerChrAction == CA_SHOT || m_dwLowerChrAction == CA_JUMPSHOT)
		{
			InitWeapon(1);
		}

		if(m_bCharDead)
		{
			m_bLowerAnimating = FALSE;
		} else
		{
			if(m_dwLowerChrAction==CA_LEFTDASH || m_dwLowerChrAction==CA_RIGHTDASH || m_dwLowerChrAction == CA_BACKDASH)
			{
				CSceneManager::CharacterFirstAccelate(m_lpChrModel,false);			
				CSceneManager::AddDelayTimer(m_lpChrModel,30);
			}

			if(GetChantFlag(26))
			{
				m_dwUpperChrAction = CA_STUN;
			} else
			{
				if(m_dwLowerChrAction == CA_SWIM)
				{
					m_dwLowerChrAction = CA_SWIM;
				} else if(m_bSitMode)
				{
					m_dwLowerChrAction = CA_REST;
				} else if(m_dwLowerChrAction != CA_FORWARDJUMP && m_dwLowerChrAction != CA_BACKJUMP &&
						m_dwLowerChrAction != CA_JUMP && m_dwLowerChrAction != CA_FRONTDASH && !m_bStillCasting)
				{
					m_dwLowerChrAction = CA_WAIT;
				}
			}

			m_bLowerAble = TRUE;
			m_bLowerAnimating = FALSE;
		}
	}
}

void CCreature::Run(float fRunFactor)
{
	if(m_bLowerAble)
	{
		if(m_bSitMode) { CrouchAndStandup(); return; }

		/*
		if(m_dwUpperChrAction == CA_ATTACK || m_dwUpperChrAction == CA_ATTACKADVANCE)
		{
			m_fRunFactor = 0.0f;

			if(!m_lpChrModel->IsActionFinished(0))
			{
				SetAction(m_dwUpperChrAction, CA_WALK);
				return;
			}
		}
		*/

		if(m_fRunFactor < 155.0f) m_fRunFactor += fRunFactor;

		SetAction(CA_RUN, CA_RUN);
	}
}

void CCreature::WalkLeft()
{
	if(m_bLowerAble)
	{
		m_fRunFactor = 0.0f;
		if(m_bSitMode) { CrouchAndStandup(); return; }

		SetAction(CA_WALKLEFT, CA_WALKLEFT);
	}
}

void CCreature::WalkRight()
{
	if(m_bLowerAble)
	{
		m_fRunFactor = 0.0f;
		if(m_bSitMode) { CrouchAndStandup(); return; }

		SetAction(CA_WALKRIGHT, CA_WALKRIGHT);
	}
}

void CCreature::WalkBack()
{
	if(m_bLowerAble)
	{
		m_fRunFactor = 0.0f;
		if(m_bSitMode) { CrouchAndStandup(); return; }

		SetAction(CA_WALKBACK, CA_WALKBACK);
	}
}

void CCreature::CrouchAndStandup(void)
{
	if(m_bUpperAble && m_bLowerAble && m_lpChrModel)
	{
		m_fRunFactor = 0.0f;

		if(GetChantFlag(27))
		{
			m_lpChrModel->SetAnimationSpeed(0.5f);
		} else
		{
			m_lpChrModel->SetAnimationSpeed(1.0f);
		}
		CSceneManager::CharacterMovementVector(m_lpChrModel, vector3(0.0f, 0.0f, 0.0f));

		if(m_bSitMode)
		{
			InitWeapon(0);
			SetAction(CA_STANDUP, CA_STANDUP);
			m_bSitMode = FALSE;
		} else
		{
			InitWeapon(0);
			SetAction(CA_SITDOWN, CA_SITDOWN);
			m_bSitMode = TRUE;
		}
	}
}

void CCreature::Wait()
{
	if(m_bUpperAble || m_bLowerAble)
	{
		m_fRunFactor = 0.0f;

		if(GetChantFlag(26))
		{
			SetAction(CA_STUN, CA_STUN);
		} else
		{
			if(m_bSitMode)
			{
	/*			if(m_dwUpperChrAction != CA_REST || m_dwLowerChrAction != CA_REST)
				{
					m_bUpperAnimating = FALSE;
					m_bLowerAnimating = FALSE;
				}*/
				SetAction(CA_REST, CA_REST);
			} else
			{
	/*			if(m_dwUpperChrAction != CA_WAIT || m_dwLowerChrAction != CA_WAIT)
				{
					m_bUpperAnimating = FALSE;
					m_bLowerAnimating = FALSE;
				}*/
				SetAction(CA_WAIT, CA_WAIT);
			}
		}
	}
}

void CCreature::Dead()
{
//	if(m_dwLowerChrAction != CA_FALLDOWN && m_dwUpperChrAction != CA_FALLDOWN)
	if(!m_bCharDead)
	{
		m_fRunFactor = 0.0f;
		m_dwAttackCombo = 0;
		m_dwSkillComboCount = 0;
		m_bSkillCombo = FALSE;
/*
		if(g_CharacterData.m_lpButtonNormal)
		{
			CSceneManager::m_EffectManager.DeleteInterfaceScript(g_CharacterData.m_lpButtonNormal);
			g_CharacterData.m_lpButtonNormal = NULL;
			g_CharacterData.m_bComboSuccess = FALSE;
		}
*/
		m_bSitMode = FALSE;
		m_fDeadTimer = 1.0f;

		m_bCharDead = TRUE;

		m_bUpperAble = TRUE;
		m_bLowerAble = TRUE;
		m_bUpperAnimating = FALSE;
		m_bLowerAnimating = FALSE;

		if(m_lpChrModel)
		{
			m_lpChrModel->SetAnimationSpeed(1.0f);
			InitWeapon(0);

			CSceneManager::CharacterMovementVector(m_lpChrModel, vector3(0.0f, 0.0f, 0.0f));
			CSceneManager::CharacterFirstAccelate(m_lpChrModel, false);

			SetAction(CA_FALLDOWN, CA_FALLDOWN);
		} else
		{
			SetAction(CA_FALLDOWN, CA_FALLDOWN);
		}
	}
}

BOOL CCreature::Attack(unsigned long dwUpperAni, unsigned long dwLowerAni)
{
	if(m_bFlying)
	{
	//	InitWeapon(1);

		if((m_dwLowerChrAction != CA_JUMPATTACK && m_dwLowerChrAction != CA_JUMPATTACK2) && m_bFlyFirstCheck)
		{
			if(m_wClass == 6 || m_wClass == 2 || m_wClass == 7 || m_wClass == 20 || m_wClass == 24)				// 점프 공격
			{
				m_bUpperAble = TRUE;
				m_bLowerAble = TRUE;
				m_bUpperAnimating = FALSE;
				m_bLowerAnimating = FALSE;

				if(KeyPressed('S') && (m_wClass == 2 || m_wClass == 7 || m_wClass == 20))		// 내려 찍기
				{
					SetAction(CA_JUMPATTACK2, CA_JUMPATTACK2);
				} else
				{
					SetAction(CA_JUMPATTACK, CA_JUMPATTACK);
				}

				return TRUE;
			}
		}
	}

	if(m_bUpperAble)
	{
	//	InitWeapon(1);

		m_fRunFactor = 0.0f;
		if(m_bSitMode) { CrouchAndStandup(); return TRUE; }

		unsigned long dwUpperAni2, dwLowerAni2;
		if(dwUpperAni == 0xFFFFFFFF && dwLowerAni == 0xFFFFFFFF)
		{
			switch(m_dwLowerChrAction)
			{
				case CA_WALK:
				case CA_RUN:
					dwUpperAni2 = CA_ATTACKADVANCE;
					dwLowerAni2 = m_dwLowerChrAction;
					break;

				case CA_WALKLEFT:
					dwUpperAni2 = CA_ATTACKLEFT;
					dwLowerAni2 = m_dwLowerChrAction;
					break;

				case CA_WALKRIGHT:
					dwUpperAni2 = CA_ATTACKRIGHT;
					dwLowerAni2 = m_dwLowerChrAction;
					break;

				case CA_WALKBACK:
					dwUpperAni2 = CA_ATTACKRETREAT;
					dwLowerAni2 = m_dwLowerChrAction;
					break;

				case CA_LEFTDASH:
					if(m_wClass == 1 || m_wClass == 5 || m_wClass == 6 || m_wClass == 19 || m_wClass == 20)		// 대쉬 공격
					{
						if(m_dwUpperChrAction == CA_LEFTDASH) m_dwUpperChrAction = CA_WAIT;
						dwUpperAni2 = CA_ATTACKLEFT;
						dwLowerAni2 = m_dwLowerChrAction;
					} else
					{
						return FALSE;
					}
					break;

				case CA_RIGHTDASH:
					if(m_wClass == 1 || m_wClass == 5 || m_wClass == 6 || m_wClass == 19 || m_wClass == 20)		// 대쉬 공격
					{
						if(m_dwUpperChrAction == CA_RIGHTDASH) m_dwUpperChrAction = CA_WAIT;
						dwUpperAni2 = CA_ATTACKRIGHT;
						dwLowerAni2 = m_dwLowerChrAction;
					} else
					{
						return FALSE;
					}
					break;

				default:
					switch(m_dwAttackCombo)
					{
						case 0:
							dwUpperAni2 = CA_ATTACK;
							dwLowerAni2 = CA_ATTACK;
							break;

						case 1:
							dwUpperAni2 = CA_ATTACK2;
							dwLowerAni2 = CA_ATTACK2;
							break;

						case 2:
							dwUpperAni2 = CA_ATTACK3;
							dwLowerAni2 = CA_ATTACK3;
							break;

						case 3:
							dwUpperAni2 = CA_ATTACK4;
							dwLowerAni2 = CA_ATTACK4;
							break;

						case 4:
							dwUpperAni2 = CA_ATTACK5;
							dwLowerAni2 = CA_ATTACK5;
							break;

						case 5:
							dwUpperAni2 = CA_ATTACK6;
							dwLowerAni2 = CA_ATTACK6;
							break;
					}
					break;
			}
		} else
		{
			dwUpperAni2 = dwUpperAni;
			dwLowerAni2 = dwLowerAni;
		}

		if(SetAction(dwUpperAni2, dwLowerAni2))
		{
			if(m_strShape[11 + m_dwWeaponPos])
			{
				if(m_lpChrModel)
				{
					if(GetChantFlag(27))
					{
						m_lpChrModel->SetAnimationSpeed(0.55f);	// 0.55
					} else
					{
						m_lpChrModel->SetAnimationSpeed(1.10f);	// 1.10
					}
				}
				/*
				switch(CCharacterControl::GetWeaponType(m_strShape[11 + m_dwWeaponPos]))
				{
					case 6:
					case 7:
					case 8:
						if(m_lpChrModel && (m_wClass == 4 || m_wClass == 11 || m_wClass == 12 || m_wClass == 3 || m_wClass == 9 || m_wClass == 10))		// 공속 느려지게 하기
						{
							if(GetChantFlag(27))
							{
								m_lpChrModel->SetAnimationSpeed(0.5f);	// 0.5
							} else
							{
								m_lpChrModel->SetAnimationSpeed(1.0f);	// 1.0
							}
						}
						break;

					case 9:
					case 10:
					case 11:
						if(m_lpChrModel && (m_wClass == 2 || m_wClass == 7 || m_wClass == 8 || m_wClass == 4 || m_wClass == 11 || m_wClass == 12 || m_wClass == 3 || m_wClass == 9 || m_wClass == 10))		// 공속 느려지게 하기
						{
							if(GetChantFlag(27))
							{
								m_lpChrModel->SetAnimationSpeed(0.475f);	// 0.475
							} else
							{
								m_lpChrModel->SetAnimationSpeed(0.95f);	// 0.95
							}
						}
						break;
				}
				*/
			}

			return TRUE;
		}
	}

	return FALSE;
}

void CCreature::Respawn()
{
	m_fRunFactor = 0.0f;
	m_bSitMode = FALSE;
	m_sDamage = 0;

	m_bCharDead = FALSE;

	for( int i=0; i < m_Arrow.size(); i++ ) {
		delete m_Arrow[i];
	}
	m_Arrow.clear();

	if(m_lpChrModel)
	{
		InitWeapon(0);
		m_lpChrModel->SetAnimationSpeed(1.0f);
	}

	for(i = 0; i < m_lstActionData.num;)
	{
		m_lstActionData.DelIndex(0);
	}
	m_lstActionData.num = 0;

	for(i = 0; i < m_lstDamageNumber.num;)
	{
		m_lstDamageNumber.DelIndex(0);
	}
	m_lstDamageNumber.num = 0;

	m_dwUpperChrAction = CA_WAIT;
	m_dwLowerChrAction = CA_WAIT;
	m_bUpperAnimating = FALSE;
	m_bLowerAnimating = FALSE;
	m_bUpperAble = TRUE;
	m_bLowerAble = TRUE;
	SetAction(CA_WAIT, CA_WAIT);
}

void CCreature::SetShape(char strShape[15][256])
{
	for(int i = 0; i < 15; i++)
	{
		strcpy(m_strShape[i], strShape[i]);
	}

	if(m_lpChrModel == NULL) return;

	if(m_cNation == 0)			// Human
	{
		m_lpChrModel->BeginOutfitSetting();
		m_lpChrModel->SetOutfitSlot("HEAD", m_strShape[0]);

		m_lpChrModel->SetOutfitSlot("BODY", m_strShape[1]);
		m_lpChrModel->SetOutfitSlot("BODY", m_strShape[2]);
		m_lpChrModel->SetOutfitSlot("BODY", m_strShape[3]);

		m_lpChrModel->SetOutfitSlot("HAND", m_strShape[4]);
		m_lpChrModel->SetOutfitSlot("FOOT", m_strShape[5]);/**/

		m_lpChrModel->EndOutfitSetting();

		m_lpChrModel->SetAttachmentSlot("WEAPON", m_strShape[11 + m_dwWeaponPos]);
		m_lpChrModel->SetAttachmentSlot("SHIELD", m_strShape[9 + m_dwWeaponPos]);
	} else if(m_cNation == 1)	// Akhan
	{
		m_lpChrModel->BeginOutfitSetting();
		m_lpChrModel->SetOutfitSlot("HEAD", m_strShape[0]);

		m_lpChrModel->SetOutfitSlot("BODY", m_strShape[3]);
		m_lpChrModel->SetOutfitSlot("PELVIS", m_strShape[5]);/**/

		m_lpChrModel->SetOutfitSlot("ARM", m_strShape[4]);
		m_lpChrModel->SetOutfitSlot("SKILL", m_strShape[9]);
		m_lpChrModel->EndOutfitSetting();

		m_lpChrModel->SetAttachmentSlot("WEAPON", m_strShape[11]);
	}

	InitWeapon(1);
}

void CCreature::SkillAttack(unsigned long dwUpperAni, unsigned int dwLowerAni)
{
	if(m_bUpperAble && m_bLowerAble)
	{
		SetAction(dwUpperAni, dwLowerAni);
	}
}

BOOL CCreature::Jump()
{
	BOOL bResult = FALSE;
	if(m_bUpperAble && m_bLowerAble && !m_bSitMode)
	{
		if(m_dwLowerChrAction != CA_WAIT)
		{
			const char *strMotionSheet = m_lpChrModel->GetCurrentMotionSheetName();

			if(strMotionSheet &&
				(!strcmp(strMotionSheet, "CLASS_ROGUE") || !strcmp(strMotionSheet, "WEAPON_SHADOW_OFF") ||
				!strcmp(strMotionSheet, "WEAPON_2CLAW") || !strcmp(strMotionSheet, "WEAPON_2DA")))
			{
				if(KeyPressed('W'))
					bResult = SetAction(CA_FRONTDASH, CA_FRONTDASH);
				else if(KeyPressed('S'))
				{
				}
				else
					SetAction(CA_JUMP, CA_JUMP);
			} else
			{
				if(KeyPressed('W'))
					bResult = SetAction(CA_FORWARDJUMP, CA_FORWARDJUMP);
				else if(KeyPressed('S'))
					bResult = SetAction(CA_BACKJUMP, CA_BACKJUMP);
				else
					SetAction(CA_JUMP, CA_JUMP);
			}

			m_bLowerAble = FALSE; 
			m_bLowerAble = FALSE;
		}
		else
		{
			SetAction(CA_JUMP, CA_JUMP);
			m_vecJumpAttackVector = vector3(0.0f, 0.0f, 0.0f);
		}

		m_bFlying = TRUE;

		//Jump sound//
		char strSoundFilename[256];	
		sprintf(strSoundFilename, "%s%s",SOUNDFILEPATH,"jump.wav");
			
		try
		{
			CSoundManager &sm = CSoundManager::GetInstance();
			ISoundObject &sb = sm.GetBuffer(strSoundFilename,true,false,1);
			int nBuffer;
			
			nBuffer = sb.Play(false);
			sb.SetPosition(nBuffer,m_vecPos.x,m_vecPos.y,m_vecPos.z);
			sb.SetDistance(nBuffer,1000.0f,2000.0f);
			
		}
		catch(exception &e)
		{
			static bool bFirstShowMessage=false;
			if(bFirstShowMessage==false)
			{
				MessageBox(NULL,e.what(),0,0);
				bFirstShowMessage=true;
			}
		}

		/////////////
		return bResult;
	}

	return bResult;
}

BOOL CCreature::Dash(int nDir)
{
	if(m_bUpperAble && !m_bSitMode)
	{
/*		m_bUpperAnimating = TRUE;
		m_bLowerAnimating = TRUE;
		m_bUpperAble = FALSE;
		m_bLowerAble = FALSE;
		*/
		/*
		CCameraControl::m_fCameraShakeRateTime=3000.0f/30.0f;
		CCameraControl::m_fCameraShakeNowTime=0.0f;
		CCameraControl::m_vecCameraShakeLength=vector3(10.0f,10.0f,10.0f);
		*/

		//CCameraControl::SetFadeOut(1000.0f,5000.0f,1000.0f);
		//CCameraControl::SetFadeOut(30.0f,60.0f,30.0f);

		/*
		color c;
		c.c=0xff660000;
		*/
		//CCameraControl::SetFadeIn(1.0f,2.0f,10.0f,c);

		//SetFadeIn(float fStart,float fMaintenance,float fEnd,color FadeColor);

		BOOL bResult;
		switch(nDir)
		{
			case 0:
				bResult = SetAction(CA_LEFTDASH, CA_LEFTDASH);
				break;

			case 1:
				bResult = SetAction(CA_RIGHTDASH, CA_RIGHTDASH);
				break;

			case 2:
				bResult = SetAction(CA_BACKDASH, CA_BACKDASH);
				break;
		}		
		m_bUpperAble = TRUE;

		return bResult;
	}

	return FALSE;
}

void CCreature::BeginCast(char *strMotion)
{
	m_bUpperAble = TRUE;
	m_bLowerAble = TRUE;
	m_bUpperAnimating = FALSE;
	m_bLowerAnimating = FALSE;

	unsigned long dwWeapon = CCharacterControl::GetWeaponType(m_strShape[11 + m_dwWeaponPos]);
	if(dwWeapon != 14 &&				// STAFF
		strcmp(strMotion, "AIMED_SHOT1"))
	{
		InitWeapon(0);
	} else
	{
		if(m_cNation == 0)
		{
			InitWeapon(1);
		} else if(m_cNation == 1)
		{
			InitWeapon(0);
		}
	}

	SetAction(strMotion, strMotion);
}

void CCreature::EndSkill(char *strMotion)
{
	m_bStillCasting = FALSE;

	m_bUpperAble = TRUE;
	m_bLowerAble = TRUE;
	m_bUpperAnimating = FALSE;
	m_bLowerAnimating = FALSE;

	if(strcmp(strMotion, "FIRE1") && strcmp(strMotion, "FIRE2") &&
		strcmp(strMotion, "SHOT") && strcmp(strMotion, "JUMP_SHOT"))
	{
		InitWeapon(1);
	}

	SetAction(strMotion, strMotion);
}

void CCreature::InitWeapon(unsigned long dwEquip)
{
	if(m_lpChrModel)
	{
		switch(dwEquip)
		{
			case 0:
				if(m_cNation == 0)
				{
					m_lpChrModel->SetMotionSheet("NO_WEAPON");
//					m_lpChrModel->SetAttachmentSlot("ETC", "");
					m_lpChrModel->SetAttachmentHolder("WEAPON", 0);
					m_lpChrModel->SetAttachmentHolder("SHIELD", 2);
					m_lpChrModel->SetAttachmentSlot("WEAPON", m_strShape[11 + m_dwWeaponPos]);
					m_lpChrModel->SetAttachmentSlot("SHIELD", m_strShape[9 + m_dwWeaponPos]);
				} else if(m_cNation == 1)
				{
					m_lpChrModel->SetMotionSheet("NO_WEAPON");
//					m_lpChrModel->SetAttachmentSlot("ETC", "");
					m_lpChrModel->SetAttachmentHolder("WEAPON", 0);
					m_lpChrModel->SetAttachmentSlot("WEAPON", m_strShape[11]);
				}
				break;

			case 1:
				if(CCharacterControl::GetMotionSheet)
				{
					if(m_bSitMode)
					{
						InitWeapon(0);
					} else
					{
						if(m_cNation == 0)
						{
							char *strMotionSheet = CCharacterControl::GetMotionSheet(m_strShape[11 + m_dwWeaponPos], m_strShape[9 + m_dwWeaponPos], m_wClass);		// 모션시트 알아내기
							m_lpChrModel->SetMotionSheet(strMotionSheet);
/*							if(!strcmp(strMotionSheet, "WEAPON_BOW") || !strcmp(strMotionSheet, "WEAPON_CROSSBOW"))
							{
								m_lpChrModel->SetAttachmentSlot("ETC", "QUIVER");
							} else
							{
								m_lpChrModel->SetAttachmentSlot("ETC", "");
							}*/

							if(!strcmp(strMotionSheet, "NO_WEAPON_B"))
							{
								m_bNoneComboAttackMode = FALSE;
							} else
							{
								m_bNoneComboAttackMode = TRUE;
							}

							m_lpChrModel->SetAttachmentSlot("WEAPON", m_strShape[11 + m_dwWeaponPos]);
							m_lpChrModel->SetAttachmentSlot("SHIELD", m_strShape[9 + m_dwWeaponPos]);
							m_lpChrModel->SetAttachmentHolder("WEAPON", 1);
							m_lpChrModel->SetAttachmentHolder("SHIELD", 3);
						} else if(m_cNation == 1)
						{
							char *strMotionSheet = CCharacterControl::GetMotionSheet(m_strShape[11], m_strShape[9], m_wClass);		// 모션시트 알아내기
							m_lpChrModel->SetMotionSheet(strMotionSheet);

							if(!strcmp(strMotionSheet, "NO_WEAPON_B"))
							{
								m_bNoneComboAttackMode = FALSE;
							} else
							{
								m_bNoneComboAttackMode = TRUE;
							}

							m_lpChrModel->SetAttachmentSlot("WEAPON", m_strShape[11]);
							m_lpChrModel->SetAttachmentHolder("WEAPON", 1);
						}
					}
				} else		// 클라이언트 외 처리
				{
					m_lpChrModel->SetMotionSheet("WEAPON_ONE_HAND");
					m_lpChrModel->SetAttachmentHolder("WEAPON", 1);
					m_bNoneComboAttackMode = TRUE;
					/*
					m_lpChrModel->SetAttachmentSlot("ETC", "");
					m_lpChrModel->SetMotionSheet("WEAPON_ONE_HAND");
					
					m_lpChrModel->SetAttachmentSlot("WEAPON","BASTARD_SWORD");
					m_lpChrModel->SetAttachmentSlot("SHIELD","LARGE_SHIELD");
					
					*/
				}
				break;
		}
	}
}

void CCreature::CancelSkill()
{
	m_bStillCasting = FALSE;

	if(m_dwUpperChrAction == CA_CASTING ||
		m_dwUpperChrAction == CA_AIMEDSHOT1 || m_dwUpperChrAction == CA_AIMEDSHOT2 ||
		m_dwUpperChrAction == CA_TURNPUNCH1 || m_dwUpperChrAction == CA_TURNPUNCH2)
	{
		m_bUpperAble = TRUE;
		m_bLowerAble = TRUE;
		m_bUpperAnimating = FALSE;
		m_bLowerAnimating = FALSE;
		m_dwUpperChrAction = CA_WAIT;
		m_dwLowerChrAction = CA_WAIT;

		Wait();
	}
}

BOOL CCreature::Casting(unsigned long dwUpperAni, unsigned long dwLowerAni)
{
	unsigned long dwWeapon = CCharacterControl::GetWeaponType(m_strShape[11 + m_dwWeaponPos]);

	m_bStillCasting = TRUE;

	if(m_bUpperAble)
	{
		if(dwWeapon != 14 &&				// STAFF
			((dwLowerAni != CA_AIMEDSHOT1 && dwLowerAni != CA_AIMEDSHOT2) && (m_dwLowerChrAction != CA_AIMEDSHOT1 && m_dwLowerChrAction != CA_AIMEDSHOT2)))
		{
			InitWeapon(0);
		} else
		{
			if(m_cNation == 0)
			{
				InitWeapon(1);
			} else if(m_cNation == 1)
			{
				InitWeapon(0);
			}
		}

		m_fRunFactor = 0.0f;
		if(m_bSitMode) { CrouchAndStandup(); return TRUE; }

		unsigned long dwUpperAni2, dwLowerAni2;
		if(dwUpperAni == 0xFFFFFFFF && dwLowerAni == 0xFFFFFFFF)
		{
			if(m_dwLowerChrAction == CA_AIMEDSHOT1)
			{
				dwUpperAni2 = CA_AIMEDSHOT2;
				dwLowerAni2 = CA_AIMEDSHOT2;
			} else if(m_dwLowerChrAction == CA_TURNPUNCH1)
			{
				dwUpperAni2 = CA_TURNPUNCH2;
				dwLowerAni2 = CA_TURNPUNCH2;
			} else
			{
				dwUpperAni2 = m_dwUpperChrAction;
				dwLowerAni2 = m_dwLowerChrAction;
			}
		} else
		{
			dwUpperAni2 = dwUpperAni;
			dwLowerAni2 = dwLowerAni;
		}

		return SetAction(dwUpperAni2, dwLowerAni2);
	}

	return FALSE;
}

void CCreature::ArrowUpdate() {
// 몸에 맞은 화살들 업데이트 
	if(m_bArrowExist) {
		int i;

		for(i=0;i<m_Arrow.size();i++) {
			
			if(CSceneManager::m_EffectManager.CheckNullScript(m_Arrow[i]->m_ArrowEsf)) //delete
				DeleteArrow(i);

			if(m_Arrow[i] != NULL) {
				
				D3DXVECTOR3 bodypos;	
				D3DXVECTOR3 effectfwd;

				CZ3DObject *body;
				if(m_lpChrModel != NULL) {
					body = m_lpChrModel->GetSkeletonPartObject(m_Arrow[i]->m_PivotName);
					if(body != NULL) {
						/*matrix *body_tm = body->GetTM();
				
						bodypos.x = body_tm->_41;
						bodypos.y = body_tm->_42;
						bodypos.z = body_tm->_43;
						*/
						vector3 body_tm;
						quaternion body_q;
						D3DXQUATERNION tmp;
						float body_scale = 0.0f;
						body_scale = m_lpChrModel->GetScale();

						body->GetDirection(body_q);
						body->GetPosition(body_tm);
						bodypos.x = body_tm.x;
						bodypos.y = body_tm.y;
						bodypos.z = body_tm.z;
						
						bodypos *= body_scale;

						tmp.x = body_q.x;
						tmp.y = body_q.y;
						tmp.z = body_q.z;
						tmp.w = body_q.w;

						m_Arrow[i]->m_ArrowEsf->SetExt4Rot(tmp);

						m_Arrow[i]->m_ArrowEsf->SetStartPos(m_vecPos.x + bodypos.x,m_vecPos.y + bodypos.y,m_vecPos.z + bodypos.z);
						float fChrDir = m_fDirection = m_lpChrModel->GetDirection();
						fChrDir = -fChrDir;
						fChrDir -= FLOAT_PHI / 2.0f;

						vector3 vecChrToward;
						vecChrToward.x = cosf(fChrDir);
						vecChrToward.z = sinf(fChrDir);	
						vecChrToward.y = 0.0f;
						vecChrToward.Normalize();

						m_Arrow[i]->m_ArrowEsf->SetChrFwd(-vecChrToward.x,-vecChrToward.y,-vecChrToward.z);	
								
					}
					else {	
						delete m_Arrow[i];
						m_Arrow[i] = NULL;	
						m_Arrow.erase(&(m_Arrow[i]));
						
					}

				}
				else {
					delete m_Arrow[i];
					m_Arrow[i] = NULL;	
					m_Arrow.erase(&(m_Arrow[i]));
				}
				
			}
		}
	}
}
void CCreature::ArrowUpdate(int i) {
	if(m_Arrow[i] != NULL) {
				
		D3DXVECTOR3 bodypos;	
		D3DXVECTOR3 effectfwd;

		CZ3DObject *body;
		if(m_lpChrModel != NULL) {
			body = m_lpChrModel->GetSkeletonPartObject(m_Arrow[i]->m_PivotName);
			if(body != NULL) {
				/*matrix *body_tm = body->GetTM();
		
				bodypos.x = body_tm->_41;
				bodypos.y = body_tm->_42;
				bodypos.z = body_tm->_43;
				*/
				vector3 body_tm;
				quaternion body_q;
				D3DXQUATERNION tmp;

				body->GetPosition(body_tm);
				body->GetDirection(body_q);

				float body_scale = 0.0f;
				body_scale = m_lpChrModel->GetScale();


				bodypos.x = body_tm.x;
				bodypos.y = body_tm.y;
				bodypos.z = body_tm.z;
				
				bodypos *= body_scale;

				tmp.x = body_q.x;
				tmp.y = body_q.y;
				tmp.z = body_q.z;
				tmp.w = body_q.w;

				m_Arrow[i]->m_ArrowEsf->SetExt4Rot(tmp);
				m_Arrow[i]->m_ArrowEsf->SetStartPos(m_vecPos.x + bodypos.x,m_vecPos.y + bodypos.y,m_vecPos.z + bodypos.z);
				float fChrDir = m_fDirection = m_lpChrModel->GetDirection();
				fChrDir = -fChrDir;
				fChrDir -= FLOAT_PHI / 2.0f;

				vector3 vecChrToward;
				vecChrToward.x = cosf(fChrDir);
				vecChrToward.z = sinf(fChrDir);	
				vecChrToward.y = 0.0f;
				vecChrToward.Normalize();

				m_Arrow[i]->m_ArrowEsf->SetChrFwd(-vecChrToward.x,-vecChrToward.y,-vecChrToward.z);	
						
			}
			else {	
				delete m_Arrow[i];
				m_Arrow[i] = NULL;	
				m_Arrow.erase(&(m_Arrow[i]));
				
			}
		}
		else {
			delete m_Arrow[i];
			m_Arrow[i] = NULL;	
			m_Arrow.erase(&(m_Arrow[i]));

		}
	}
}
void CCreature::AddArrow(char *pivot,D3DXQUATERNION rot,int division) {
	CCreatureArrow *AddNode;
	AddNode = new CCreatureArrow;
	strcpy(AddNode->m_PivotName,pivot);
	if(m_Arrow.size() > 2) { // 화살갯수 제한
		delete m_Arrow[0];
		m_Arrow.erase(&m_Arrow[0]);
	}

	m_Arrow.push_back(AddNode);
	m_bArrowExist = true;
	AddNode->m_ArrowEsf = new CEffScript;
	AddNode->m_ArrowEsf->SetExt4SelfInfo(rot);
	CSceneManager::AddEffectScript((AddNode->m_ArrowEsf));
	switch(division) {
	case 0:
		if(rand() % 2)
			AddNode->m_ArrowEsf->GetScriptData("arrow_body.esf");
		else
			AddNode->m_ArrowEsf->GetScriptData("arrow_body2.esf");
		break;
	case 1:
		AddNode->m_ArrowEsf->GetScriptData("dagger_body1.esf");
		break;
	case 2:
		AddNode->m_ArrowEsf->GetScriptData("dagger_body2.esf");
		break;
	case 3:
		AddNode->m_ArrowEsf->GetScriptData("dagger_body3.esf");
		break;	
	case 4:
		AddNode->m_ArrowEsf->GetScriptData("dagger_body4.esf");
		break;
	case 5:
		AddNode->m_ArrowEsf->GetScriptData("dagger_body5.esf");
		break;
	
	}

	ArrowUpdate(m_Arrow.size() -1);
}

void CCreature::SetSlideValue(CEffScript::CEffExt6 value){

	m_SlideValue = value;
	m_bSlide = true;
}

void CCreature::PlaySlide() {
	
	if(GetChantFlag(25)) { // hold시 slide 작동 x 
		m_bSlide = false;
		return ;
	}

	if(m_bSlide) {
		float fChrDir = GetDirection();

		fChrDir = -fChrDir;
		fChrDir -= FLOAT_PHI / 2.0f;

		vector3 vecChrToward;
		
		vecChrToward.x = cosf(fChrDir);
		vecChrToward.z = sinf(fChrDir);	
		vecChrToward.y = 0.0f;
		vecChrToward.Normalize();

		vector3 tmp;
		vector3 *char_pos;
		float tmp_length;

		if(m_SlideValue.m_CurrentSlideLength < m_SlideValue.m_SlideLength)
		{
			tmp  = vecChrToward * (m_SlideValue.m_SlideSpeed);
			tmp *= (-1.0f);
			m_SlideValue.m_SlideSpeed += m_SlideValue.m_SlideAccel;
			
			if(m_SlideValue.m_SlideAccel <= 0.0f)
			{
				if(m_SlideValue.m_SlideSpeed < m_SlideValue.m_LimitSpeed)
					m_SlideValue.m_SlideSpeed = m_SlideValue.m_LimitSpeed;
			}
			else
			{
				if(m_SlideValue.m_SlideSpeed > m_SlideValue.m_LimitSpeed)
					m_SlideValue.m_SlideSpeed = m_SlideValue.m_LimitSpeed;
			}
		}
		else
		{
			tmp.x = 0.0f;
			tmp.y = 0.0f;
			tmp.z = 0.0f;
			m_bSlide = false;
		}
		tmp_length = tmp.GetLens();
		m_SlideValue.m_CurrentSlideLength += tmp_length;

		vector3 before_pos;

		char_pos = GetPosition();	
		
		before_pos.x = char_pos->x;
		before_pos.y = char_pos->y;
		before_pos.z = char_pos->z;

		SetPosition(char_pos->x + tmp.x,char_pos->y,char_pos->z + tmp.z);
		// slide 먼지 render
		if(m_bSlide && (!m_bFlying))
			//RenderSlide(before_pos.x - tmp.x,before_pos.y,before_pos.z - tmp.x,char_pos->x - tmp.x,char_pos->y,char_pos->z - tmp.x,30.0f);
			RenderSlide(before_pos.x,before_pos.y,before_pos.z,char_pos->x,char_pos->y,char_pos->z,30.0f);

		/*if(m_SlideEffect != NULL && m_bSlide) { //snap
			if(!CSceneManager::m_EffectManager.CheckNullScript(m_SlideEffect)) {
				m_SlideEffect->SetSnapPos(char_pos->x + tmp.x,char_pos->y,char_pos->z + tmp.z);	
			}
			else 
				m_SlideEffect = NULL;
		}*/

	}	
}
void CCreature::RenderSlide(float beforex,float beforey,float beforez,float nowx,float nowy,float nowz,float unitsize) {
	//unitsize : 이팩트 사이 간격
	float vec_length = 0.0f;
	int unitcount = 0;

	D3DXVECTOR3 tmp_vec;
	D3DXVECTOR3 tmp_vec2(0.0f,0.0f,0.0f);

	D3DXVECTOR3 r_foot;
	D3DXVECTOR3 l_foot;

	tmp_vec.x = nowx - beforex;
	tmp_vec.y = nowy - beforey;
	tmp_vec.z = nowz - beforez;
	
	vec_length = D3DXVec3Length(&tmp_vec);
	D3DXVec3Normalize(&tmp_vec,&tmp_vec);
	
	CZ3DObject *snappoint = NULL;
	float body_scale = 0.0f;

	if(m_lpChrModel == NULL) //model 이 NULL 일때 skip
		return;
	//rfoot				
	snappoint = m_lpChrModel->GetSkeletonPartObject("R_FOOT");
	body_scale = m_lpChrModel->GetScale();
	
	if(snappoint != NULL) {
		
		vector3 snaptm;
		snappoint->GetPosition(snaptm);
		 
		r_foot.x = snaptm.x;
		r_foot.y = snaptm.y;
		r_foot.z = snaptm.z;

		r_foot *= body_scale;
	}
	//lfoot
	snappoint = m_lpChrModel->GetSkeletonPartObject("L_FOOT");
	body_scale = m_lpChrModel->GetScale();
	
	if(snappoint != NULL) {
		vector3 snaptm;
		snappoint->GetPosition(snaptm);
		 
		l_foot.x = snaptm.x;
		l_foot.y = snaptm.y;
		l_foot.z = snaptm.z;

		l_foot *= body_scale;
	}
			
	while(vec_length > D3DXVec3Length(&tmp_vec2)) { 
		// 이번에 미끌린 거리와 그 이전의 위치 사이에 effect 출력  
		
		D3DXVECTOR3 effectpos(nowx,nowy,nowz);
		
		tmp_vec2 += tmp_vec * unitsize;
		//rfoot
		CX3DEffect *pEffect = NULL;
		pEffect=new CX3DEffect;
		CSceneManager::AddEffect(pEffect);
		pEffect->Load(EFFECTPATH,"smoke.eff");
		pEffect->SetLoop(FALSE);				
		pEffect->SetAxis(0.0f,0.0f,0.0f);
		pEffect->SetCenter(effectpos.x - tmp_vec2.x + r_foot.x,
						   effectpos.y - tmp_vec2.y + r_foot.y + 20.0f,
						   effectpos.z - tmp_vec2.z + r_foot.z);
		pEffect->SetFrame((float)(unitcount * 2.0f));
		 
		//lfoot
		CX3DEffect *pEffect2 = NULL;
		pEffect2=new CX3DEffect;
		CSceneManager::AddEffect(pEffect2);
		pEffect2->Load(EFFECTPATH,"smoke.eff");
		pEffect2->SetLoop(FALSE);				
		pEffect2->SetAxis(0.0f,0.0f,0.0f);
		pEffect2->SetCenter(effectpos.x - tmp_vec2.x + l_foot.x,
						   effectpos.y - tmp_vec2.y + l_foot.y + 20.0f,
						   effectpos.z - tmp_vec2.z + l_foot.z);
		pEffect2->SetFrame((float)(unitcount * 2.0f));
		
		unitcount++;
	}
}

void CCreature::DeleteArrow(int index) {
	int i;
	for(i=0;i<m_Arrow.size();i++) {
		delete m_Arrow[i];
		m_Arrow[i] = NULL;
		//m_Arrow.erase(&(m_Arrow[i]));
	}
	m_Arrow.clear();

}
	

void CCreature::DeleteBodyEffect(unsigned long id) { //effect id로 delete

	int i;

	for( i = m_BodyEffect.size() - 1; i >= 0; i-- )
	{
		if(m_BodyEffect[i]->m_EffId == id) {
			delete m_BodyEffect[i];
			m_BodyEffect[i] = NULL;	
			m_BodyEffect.erase(&(m_BodyEffect[i]));
		}
	}
	if(m_BodyEffect.size() <= 0) {
		m_bBodyEffect = false;
		m_BodyEffect.clear();
	}
}

void CCreature::DeleteBodyEffect(char *pivot) {
	int i;
	if(pivot != NULL)
	{
		for( i = m_BodyEffect.size() - 1; i >= 0; i-- )
		{
			if(strlen(m_BodyEffect[i]->m_PivotName) > 1) {
				if(!strcmp(m_BodyEffect[i]->m_PivotName,pivot)) {
					delete m_BodyEffect[i];
					m_BodyEffect[i] = NULL;	
					m_BodyEffect.erase(&(m_BodyEffect[i]));
				}
			}
		}
		if(m_BodyEffect.size() <= 0) {
			m_bBodyEffect = false;
			m_BodyEffect.clear();
		}
	}
/*
	int i;
	if(pivot != NULL){
		for(i=0;i<m_BodyEffect.size();i++) {
			if(strlen(m_BodyEffect[i]->m_PivotName) > 1) {
				if(!strcmp(m_BodyEffect[i]->m_PivotName,pivot)) {
					delete m_BodyEffect[i];
					m_BodyEffect[i] = NULL;	
					m_BodyEffect.erase(&(m_BodyEffect[i]));
				}
			}
		}
		if(m_BodyEffect.size() <= 0) {
			m_bBodyEffect = false;
			m_BodyEffect.clear();
		}
	}
*/
}
void CCreature::DeleteBodyEffectName(char *effectname) {

	int i;

	for(i = m_BodyEffect.size() - 1; i >= 0; i-- )
	{
		if(!CSceneManager::m_EffectManager.CheckNullScript(m_BodyEffect[i]->m_Effect)) {	
			if(!strcmp(effectname,m_BodyEffect[i]->m_Effect->m_FileName)) {
				delete m_BodyEffect[i];
				m_BodyEffect[i] = NULL;	
				m_BodyEffect.erase(&(m_BodyEffect[i]));
			}
		}
		else {
			delete m_BodyEffect[i];
			m_BodyEffect[i] = NULL;	
			m_BodyEffect.erase(&(m_BodyEffect[i]));
		}
	}
	if(m_BodyEffect.size() <= 0) {
		m_bBodyEffect = false;
		m_BodyEffect.clear();
	}
}
void CCreature::DeleteBodyEffect() {
	int i;
	for( i = m_BodyEffect.size() - 1; i >= 0; i-- )
	{
		delete m_BodyEffect[i];
		m_BodyEffect[i] = NULL;
	}
	m_bBodyEffect = false;

	m_BodyEffect.clear();

}
//현재 body effect list안에 이 이팩트가 존재 하는지 검사
bool CCreature::CheckInBodyEffect(char *file) {
	int i;
	for(i=0;i<m_BodyEffect.size();i++) {
		if(strstr(m_BodyEffect[i]->m_Effect->m_FileName,file) != NULL) 
			return true;
	}
	return false;
}
// pivot index에 effect 붙임
void CCreature::AddBodyEffect(char *filename,int pivotindex,bool rot,unsigned long effid) {

	
	char *ptr = strrchr(filename,'.');

	D3DXQUATERNION tmpquat(0.0f,0.0f,0.0f,1.0f);
	long pivotnum = 0;
	if(!m_lpChrModel)
		return;

	m_lpChrModel->GetSkeletonSet(&pivotnum);
	if((filename == NULL) || (pivotindex < 0) || (pivotindex >= pivotnum)) 
		return;

	if(!m_lpChrModel)
		return;

/*	if(CheckInBodyEffect(filename)) { // 기존에 있던 같은 종류의 effect 를 삭제후 이번 것을 올린다.
		DeleteBodyEffectName(filename);
	}
*/
	m_bBodyEffect = true;
	CCreatureEffect *tmp_node = NULL;
	tmp_node = new CCreatureEffect;
	m_BodyEffect.push_back(tmp_node);
	
	if(strstr(ptr,"eff") != NULL) { //'snap' eff use
		tmp_node->m_EffValue = true;
		tmp_node->m_bPivotRot = rot;
		tmp_node->m_PivotIndex = pivotindex;
		tmp_node->m_EffId = effid;

		strcpy(tmp_node->m_EffName,filename);
	}
	else { //'snap' esf use

		tmp_node->m_EffId = effid;
		tmp_node->m_EffValue = false;
		tmp_node->m_bPivotRot = rot;
		tmp_node->m_Effect = new CEffScript;
		tmp_node->m_Effect->GetScriptData(filename);
		if(rot)
			tmp_node->m_Effect->SetExt4SelfInfo(tmpquat);
		tmp_node->m_PivotIndex = pivotindex;
		CSceneManager::m_EffectManager.AddEffScript(tmp_node->m_Effect);
	}
	BodyEffectUpdate(m_BodyEffect.size() -1);
			
}
// pivot 하나에 effect 붙임 
void CCreature::AddBodyEffect(char *filename,char *pivot,bool rot,unsigned long effid) {

	

	char *ptr = strrchr(filename,'.');

	D3DXQUATERNION tmpquat(0.0f,0.0f,0.0f,1.0f);

	if((filename == NULL) || (pivot == NULL)) 
		return;

	if(!m_lpChrModel)
		return;

/*	if(CheckInBodyEffect(filename)) { // 기존에 있던 같은 종류의 effect 를 삭제후 이번 것을 올린다.
		DeleteBodyEffectName(filename);
	}
*/
	m_bBodyEffect = true;
	CCreatureEffect *tmp_node = NULL;
	tmp_node = new CCreatureEffect;
	m_BodyEffect.push_back(tmp_node);
	
	if(strstr(ptr,"eff") != NULL) { //snap eff use
		tmp_node->m_EffId = effid;
		tmp_node->m_EffValue = true;
		tmp_node->m_bPivotRot = rot;
		strcpy(tmp_node->m_PivotName,pivot);
		strcpy(tmp_node->m_EffName,filename);
	}
	else { //'snap' esf use
		tmp_node->m_EffId = effid;

		tmp_node->m_bPivotRot = rot;
		tmp_node->m_Effect = new CEffScript;
		tmp_node->m_Effect->GetScriptData(filename);
		strcpy(tmp_node->m_PivotName,pivot);
		if(rot)
			tmp_node->m_Effect->SetExt4SelfInfo(tmpquat);
		CSceneManager::m_EffectManager.AddEffScript(tmp_node->m_Effect);
	}
	BodyEffectUpdate(m_BodyEffect.size() -1);
}

// pivot 중에 렌덤 하게 num 갯수 만큼 effect 붙임 (num 값이 -1이면 전 pivot 에 다 붙임)
void CCreature::AddBodyEffect(char *filename,bool rot,unsigned long effid,int num) {


	int i;
	long pivotnum = 0;

	
	D3DXQUATERNION tmpquat(0.0f,0.0f,0.0f,1.0f);

	if(!m_lpChrModel)
		return;

	m_lpChrModel->GetSkeletonSet(&pivotnum);
	
	if(pivotnum <= 0)
		return;

	
	if((filename == NULL) || (strlen(filename) < 1))
		return;

		
/*	if(CheckInBodyEffect(filename)) { // 기존에 있던 같은 종류의 effect 를 삭제후 이번 것을 올린다.
		DeleteBodyEffectName(filename);
	}
*/

	m_bBodyEffect = true;

	if(num >0) {
		for(i=0;i<num;i++) {
			CCreatureEffect *tmp_node = NULL;
			tmp_node = new CCreatureEffect;
			m_BodyEffect.push_back(tmp_node);
			tmp_node->m_EffId = effid;

			tmp_node->m_bPivotRot = rot;
			tmp_node->m_Effect = new CEffScript;
			tmp_node->m_Effect->GetScriptData(filename);
			tmp_node->m_PivotIndex = rand() % pivotnum;
			if(rot)
				tmp_node->m_Effect->SetExt4SelfInfo(tmpquat);
			CSceneManager::m_EffectManager.AddEffScript(tmp_node->m_Effect);
			BodyEffectUpdate(m_BodyEffect.size() -1);
		}	
	
	}
	else if(num == -1) { // 전 pivot에 effect 붙임
		for(i=0;i<pivotnum;i++) {
			CCreatureEffect *tmp_node = NULL;
			tmp_node = new CCreatureEffect;
			m_BodyEffect.push_back(tmp_node);
			tmp_node->m_bPivotRot = rot;
			tmp_node->m_Effect = new CEffScript;
			tmp_node->m_Effect->GetScriptData(filename);
			tmp_node->m_PivotIndex = i;
			tmp_node->m_EffId = effid;
			if(rot)
				tmp_node->m_Effect->SetExt4SelfInfo(tmpquat);
			CSceneManager::m_EffectManager.AddEffScript(tmp_node->m_Effect);
			BodyEffectUpdate(m_BodyEffect.size() -1);
		}
	}
	else { // num 0
		return;
	}

}
// 캐릭의 센터에 effect 붙일경우
void CCreature::AddBodyEffect(char *filename,unsigned long effid,bool mine,bool bvis) {
	

	if(!m_lpChrModel)
		return;
	
	if((filename == NULL) || (strlen(filename) < 1))
		return;

	if(CheckInBodyEffect(filename)) { // 기존에 같은 종류의 effect 가 있다면 이번것 무시.
		return;
		//DeleteBodyEffectName(filename);
	}
	m_bBodyEffect = true;

	CCreatureEffect *tmp_node = NULL;
	tmp_node = new CCreatureEffect;
	m_BodyEffect.push_back(tmp_node);
	tmp_node->m_bPivotRot = false;
	tmp_node->m_EffId = effid;

	tmp_node->m_Effect = new CEffScript;
	tmp_node->m_Effect->GetScriptData(filename);
	//누구의 것인지
	tmp_node->m_Effect->SetMine(mine);

	tmp_node->m_Effect->SetChant(true);

	//////////////// Monster Effect
	// 캐릭 방향 생성
	float fChrDir = m_fDirection;
	fChrDir = -fChrDir;
	fChrDir -= FLOAT_PHI / 2.0f;

	vector3 vecChrToward;
		
	vecChrToward.x = cosf(fChrDir);
	vecChrToward.z = sinf(fChrDir);	
	vecChrToward.y = 0.0f;
	vecChrToward.Normalize();

	tmp_node->m_Effect->SetChr(m_lpChrModel,m_lpChrModel);
	tmp_node->m_Effect->SetChrFwd(-vecChrToward.x,-vecChrToward.y,-vecChrToward.z);

	////////////////
	CSceneManager::m_EffectManager.AddEffScript(tmp_node->m_Effect);
	BodyEffectUpdate(m_BodyEffect.size() -1);

}
void CCreature::BodyEffectUpdate(int i) {
	if(m_BodyEffect[i] != NULL) {
				
		D3DXVECTOR3 bodypos;	
		D3DXVECTOR3 effectfwd;

		//modified by Ppu // CZ3DObject body;
		CZ3DObject* body;
		CZ3DSkeletonObject *pivotarray = NULL;
		long pivotnum = 0;
		
		if(m_lpChrModel != NULL) {
			if(m_BodyEffect[i]->m_PivotIndex != -1) {
				pivotarray = m_lpChrModel->GetSkeletonSet(&pivotnum);
				
			}
			else if(strlen(m_BodyEffect[i]->m_PivotName) > 1){
				CZ3DObject *tmp_ptr = NULL;
				tmp_ptr = m_lpChrModel->GetSkeletonPartObject(m_BodyEffect[i]->m_PivotName);
				if(tmp_ptr == NULL) {	
					delete m_BodyEffect[i];
					m_BodyEffect[i] = NULL;	
					m_BodyEffect.erase(&(m_BodyEffect[i]));

					return;
				}
				//modified by Ppu // body = (*tmp_ptr);
				body = tmp_ptr;
			}
			else {
				vector3 charpos = m_lpChrModel->GetPosition();
				m_BodyEffect[i]->m_Effect->SetStartPos(charpos.x,charpos.y,charpos.z);
				float fChrDir = m_fDirection = m_lpChrModel->GetDirection();
				fChrDir = -fChrDir;
				fChrDir -= FLOAT_PHI / 2.0f;

				vector3 vecChrToward;
				vecChrToward.x = cosf(fChrDir);
				vecChrToward.z = sinf(fChrDir);	
				vecChrToward.y = 0.0f;
				vecChrToward.Normalize();

				m_BodyEffect[i]->m_Effect->SetChrFwd(-vecChrToward.x,-vecChrToward.y,-vecChrToward.z);	
				return ;
			}
			if(1) {
				vector3 body_tm;
				quaternion body_q;
				D3DXQUATERNION tmp;
				if(m_BodyEffect[i]->m_PivotIndex!=-1) {
					pivotarray[m_BodyEffect[i]->m_PivotIndex].GetPosition(body_tm);
					pivotarray[m_BodyEffect[i]->m_PivotIndex].GetDirection(body_q);

				}
				else {
					//modified by Ppu // body.GetPosition(body_tm);
					//modified by Ppu // body.GetDirection(body_q);
					body->GetPosition(body_tm);
					body->GetDirection(body_q);
				}
				float body_scale = 0.0f;
				body_scale = m_lpChrModel->GetScale();


				bodypos.x = body_tm.x;
				bodypos.y = body_tm.y;
				bodypos.z = body_tm.z;
				
				bodypos *= body_scale;

				tmp.x = body_q.x;
				tmp.y = body_q.y;
				tmp.z = body_q.z;
				tmp.w = body_q.w;
				if(m_BodyEffect[i]->m_EffValue) { //m_BodyEffect[i] use eff file 
					///////////
				
					m_BodyEffect[i]->m_EffPos.x = m_vecPos.x + bodypos.x;
					m_BodyEffect[i]->m_EffPos.y = m_vecPos.y + bodypos.y;
					m_BodyEffect[i]->m_EffPos.z = m_vecPos.z + bodypos.z;
					
					//////////
				}
				else { // m_BodyEffect[i] use esf file
					if(m_BodyEffect[i]->m_bPivotRot)	
						m_BodyEffect[i]->m_Effect->SetExt4Rot(tmp);
				
					m_BodyEffect[i]->m_Effect->SetStartPos(m_vecPos.x + bodypos.x,m_vecPos.y + bodypos.y,m_vecPos.z + bodypos.z);
					float fChrDir = m_fDirection = m_lpChrModel->GetDirection();
					fChrDir = -fChrDir;
					fChrDir -= FLOAT_PHI / 2.0f;

					vector3 vecChrToward;
					vecChrToward.x = cosf(fChrDir);
					vecChrToward.z = sinf(fChrDir);	
					vecChrToward.y = 0.0f;
					vecChrToward.Normalize();

					m_BodyEffect[i]->m_Effect->SetChrFwd(-vecChrToward.x,-vecChrToward.y,-vecChrToward.z);	
				}		
			}
			else {	
			
				delete m_BodyEffect[i];
				m_BodyEffect[i] = NULL;	
				m_BodyEffect.erase(&(m_BodyEffect[i]));
				
			}
		}
		else {
			
			delete m_BodyEffect[i];
			m_BodyEffect[i] = NULL;	
			m_BodyEffect.erase(&(m_BodyEffect[i]));

		}
	}
}
void CCreature::BodyEffectUpdate() {

	if(m_bBodyEffect) {
		int i;

		for(i=0;i<m_BodyEffect.size();i++) {
			if((m_BodyEffect[i] != NULL) && (m_BodyEffect[i]->m_EffValue || (!CSceneManager::m_EffectManager.CheckNullScript(m_BodyEffect[i]->m_Effect)))) {
				
				D3DXVECTOR3 bodypos;	
				D3DXVECTOR3 effectfwd;

				//modified by Ppu // CZ3DObject body;
				CZ3DObject* body;
				CZ3DSkeletonObject *pivotarray = NULL;
				long pivotnum = 0;

				if(m_lpChrModel != NULL) {
					if(m_BodyEffect[i]->m_PivotIndex != -1) {
						pivotarray = m_lpChrModel->GetSkeletonSet(&pivotnum);
					}
					else if(strlen(m_BodyEffect[i]->m_PivotName)>1){
						CZ3DObject *tmp_ptr = NULL;
						tmp_ptr = m_lpChrModel->GetSkeletonPartObject(m_BodyEffect[i]->m_PivotName);
						if(tmp_ptr == NULL) {
							delete m_BodyEffect[i];
							m_BodyEffect[i] = NULL;	
							m_BodyEffect.erase(&(m_BodyEffect[i]));

							return;
						}
						//modified by Ppu // body = (*tmp_ptr);
						body = tmp_ptr;
					}
					else {
						vector3 charpos = m_lpChrModel->GetPosition();
						m_BodyEffect[i]->m_Effect->SetStartPos(charpos.x,charpos.y,charpos.z);
						float fChrDir = m_fDirection = m_lpChrModel->GetDirection();
						fChrDir = -fChrDir;
						fChrDir -= FLOAT_PHI / 2.0f;

						vector3 vecChrToward;
						vecChrToward.x = cosf(fChrDir);
						vecChrToward.z = sinf(fChrDir);	
						vecChrToward.y = 0.0f;
						vecChrToward.Normalize();

						m_BodyEffect[i]->m_Effect->SetChrFwd(-vecChrToward.x,-vecChrToward.y,-vecChrToward.z);	
						continue;
					}					
					if(1) {
						
						vector3 body_tm;
						quaternion body_q;
						D3DXQUATERNION tmp;
						float body_scale = 0.0f;
						body_scale = m_lpChrModel->GetScale();

						if(m_BodyEffect[i]->m_PivotIndex != -1) {

							pivotarray[m_BodyEffect[i]->m_PivotIndex].GetPosition(body_tm);
							pivotarray[m_BodyEffect[i]->m_PivotIndex].GetDirection(body_q);

						}
						else {
							//modified by Ppu // body.GetDirection(body_q);
							//modified by Ppu // body.GetPosition(body_tm);
							body->GetDirection(body_q);
							body->GetPosition(body_tm);
						}
						bodypos.x = body_tm.x;
						bodypos.y = body_tm.y;
						bodypos.z = body_tm.z;
						
						bodypos *= body_scale;

						tmp.x = body_q.x;
						tmp.y = body_q.y;
						tmp.z = body_q.z;
						tmp.w = body_q.w;

						if(m_BodyEffect[i]->m_EffValue) { //m_BodyEffect[i] use eff file 
							///////////
							
							//snap effect render(30.0f : effect 간격)
							RenderSnap(m_BodyEffect[i]->m_EffPos.x,m_BodyEffect[i]->m_EffPos.y,m_BodyEffect[i]->m_EffPos.z,
										m_vecPos.x + bodypos.x,m_vecPos.y + bodypos.y,m_vecPos.z + bodypos.z,30.0f,m_BodyEffect[i]->m_EffName);
							m_BodyEffect[i]->m_EffPos.x = m_vecPos.x + bodypos.x;
							m_BodyEffect[i]->m_EffPos.y = m_vecPos.y + bodypos.y;
							m_BodyEffect[i]->m_EffPos.z = m_vecPos.z + bodypos.z;
							
							//////////
						}
						else { //m_BodyEffect[i] use esf file

							if(m_BodyEffect[i]->m_bPivotRot)
								m_BodyEffect[i]->m_Effect->SetExt4Rot(tmp);
						
							m_BodyEffect[i]->m_Effect->SetStartPos(m_vecPos.x + bodypos.x,m_vecPos.y + bodypos.y,m_vecPos.z + bodypos.z);
							float fChrDir = m_fDirection = m_lpChrModel->GetDirection();
							fChrDir = -fChrDir;
							fChrDir -= FLOAT_PHI / 2.0f;

							vector3 vecChrToward;
							vecChrToward.x = cosf(fChrDir);
							vecChrToward.z = sinf(fChrDir);	
							vecChrToward.y = 0.0f;
							vecChrToward.Normalize();

							m_BodyEffect[i]->m_Effect->SetChrFwd(-vecChrToward.x,-vecChrToward.y,-vecChrToward.z);	
						}								
					}
					else {	
						delete m_BodyEffect[i];
						m_BodyEffect[i] = NULL;	
						m_BodyEffect.erase(&(m_BodyEffect[i]));
		
					}

				}
				else {
					delete m_BodyEffect[i];
					m_BodyEffect[i] = NULL;	
					m_BodyEffect.erase(&(m_BodyEffect[i]));
				}		
			}
			else {//if((m_BodyEffect[i] != NULL) && (!CSceneManager::m_EffectManager.CheckNullScript(m_BodyEffect[i]->m_Effect))) {
				if(!CSceneManager::m_EffectManager.CheckNullScript(m_BodyEffect[i]->m_Effect)) {
					delete m_BodyEffect[i];
				}
				m_BodyEffect[i] = NULL;	
				m_BodyEffect.erase(&(m_BodyEffect[i]));
			}
		}//for
	}//if

}
void CCreature::SetEffect() { // 나중에 character에 effect 붙일때 쓰는 코드 
							  // GCMDS 에서 캐릭에 붙는 effect filename과 pivot 명을 넘겨줌  
/*	if(m_lpChrModel != NULL) {
		//if(strstr(m_lpChrModel->GetGCMDSFileName(),"PC_Akhan_A.GCMDS") != NULL) {
		long effectnum = 0;
		const Z3D_EFFECT_INFO **ChrEffect;
		effectnum = m_lpChrModel->GetEffectInfoList(ChrEffect);	
		DeleteBodyEffect();
		for(int i=0;i<effectnum;i++) {
			AddBodyEffect(ChrEffect[i]->szESFName,ChrEffect[i]->szSkelName,true);
		}
		//}

	}
*/
}

void CCreature::RenderSnap(float beforex,float beforey,float beforez,float nowx,float nowy,float nowz,float unitsize,char *eff) {
	// snap effect 중 eff 를 이용하는 것들.
	//unitsize : 이팩트 사이 간격

	float vec_length = 0.0f;
	int unitcount = 0;

	D3DXVECTOR3 tmp_vec;
	D3DXVECTOR3 tmp_vec2(0.0f,0.0f,0.0f);

	tmp_vec.x = nowx - beforex;
	tmp_vec.y = nowy - beforey;
	tmp_vec.z = nowz - beforez;
	
	vec_length = D3DXVec3Length(&tmp_vec);
	D3DXVec3Normalize(&tmp_vec,&tmp_vec);

	while(vec_length > D3DXVec3Length(&tmp_vec2)) { 
	
		
		D3DXVECTOR3 effectpos(nowx,nowy,nowz);
		
		tmp_vec2 += tmp_vec * unitsize;
		//rfoot
		CX3DEffect *pEffect = NULL;
		pEffect=new CX3DEffect;
		CSceneManager::AddEffect(pEffect);
		pEffect->Load(EFFECTPATH,eff);
		pEffect->SetLoop(FALSE);				
		pEffect->SetAxis(0.0f,0.0f,0.0f);
		pEffect->SetCenter(effectpos.x - tmp_vec2.x,
						   effectpos.y - tmp_vec2.y,
						   effectpos.z - tmp_vec2.z);
		pEffect->SetFrame((float)(unitcount * 2.0f));
		unitcount++;
	}
}

BOOL CCreature::GetSkillMotion()
{
	if(m_dwLowerChrAction == CA_SHOT || m_dwLowerChrAction == CA_JUMPSHOT || m_dwLowerChrAction == CA_FIRE1 ||
		m_dwLowerChrAction == CA_FIRE2 || m_dwLowerChrAction == CA_AIMEDSHOT1 || m_dwLowerChrAction == CA_AIMEDSHOT2 ||
		m_dwLowerChrAction == CA_AIMEDSHOT3 || m_dwLowerChrAction == CA_OVERBASH1 || m_dwLowerChrAction == CA_OVERBASH2 ||
		m_dwLowerChrAction == CA_OVERBASH3 || m_dwLowerChrAction == CA_OVERBASH4 || m_dwLowerChrAction == CA_OVERBASH5 ||
		m_dwLowerChrAction == CA_TURNPUNCH1 || m_dwLowerChrAction == CA_TURNPUNCH2 || m_dwLowerChrAction == CA_TURNPUNCH3 ||
		m_dwLowerChrAction == CA_COMBINATIONBLOW || m_dwLowerChrAction == CA_BACKSTAB || m_dwLowerChrAction == CA_POWERDRAIN ||
		m_dwLowerChrAction == CA_BASH || m_dwLowerChrAction == CA_ROUNDSWING)
	{
		return TRUE;
	}

	return FALSE;
}

void CCreature::SetChantEffect(unsigned long dwChant, BOOL bSelf)
{
	unsigned long i, dwChantFlag;
	for(i = 0; i < 32; i++)
	{
		dwChantFlag = 0x00000001 << i;

		if(dwChant & dwChantFlag)
			SetChantEffect(i + 1, TRUE, bSelf);
		else
			SetChantEffect(i + 1, FALSE, bSelf);
	}

	m_dwChant = dwChant;
}

void CCreature::SetChantEffect(unsigned long dwChant, BOOL bToggle, BOOL bSelf)
{
	bool bMySelf;
	if(bSelf) bMySelf = true; else bMySelf = false;

	if(bToggle)
	{
		switch(dwChant)
		{
			case 1:
				AddBodyEffect("Chant_BattleSong.esf",(unsigned long)0, bMySelf);
				break;

			case 2:
				AddBodyEffect("Chant_MaintenanceChant.esf",(unsigned long)0, bMySelf);
				break;

			case 3:
				AddBodyEffect("Chant_AccelerationChant.esf",(unsigned long)0, bMySelf);
				break;

			case 4:
				AddBodyEffect("Chant_LifeAura.esf",(unsigned long)0, bMySelf);
				break;

			case 17:
				break;

			case 18:
				AddBodyEffect("Chant_ManaShell2.esf",(unsigned long)0, bMySelf);
				break;
			
			case 19:
				AddBodyEffect("Chant_Encourage.esf",(unsigned long)0, bMySelf);
				break;

			case 20:
				AddBodyEffect("Chant_EnchantWeapon.esf",(unsigned long)0, bMySelf);
				break;

			case 21:
				AddBodyEffect("Chant_BrightArmor.esf",(unsigned long)0, bMySelf);
				break;

			case 22:
				AddBodyEffect("Chant_HardenSkin.esf",(unsigned long)0, bMySelf);
				break;

			case 23:
				AddBodyEffect("Chant_Flexibility.esf",(unsigned long)0, bMySelf);
				break;

			case 24:
				AddBodyEffect("Chant_Guard.esf",(unsigned long)0, bMySelf);
				break;

			case 25:
				AddBodyEffect("Chant_Hold.esf",(unsigned long)0, bMySelf);
				break;

			case 26:
				AddBodyEffect("Chant_Stun.esf",(unsigned long)0, bMySelf);
				break;

			case 27:
				AddBodyEffect("Chant_Frozen.esf",(unsigned long)0, bMySelf);
				break;

			case 28:
				AddBodyEffect("Chant_Poisoned.esf",(unsigned long)0, bMySelf);
				break;

			case 29:
				AddBodyEffect("Chant_LowerStrength.esf",(unsigned long)0, bMySelf);
				break;
		}
		m_dwChant += (0x00000001 << (dwChant - 1));
	} else
	{
		switch(dwChant)
		{
			case 1:
				DeleteBodyEffectName("Chant_BattleSong.esf");
				break;

			case 2:
				DeleteBodyEffectName("Chant_MaintenanceChant.esf");
				break;

			case 3:
				DeleteBodyEffectName("Chant_AccelerationChant.esf");
				break;

			case 4:
				DeleteBodyEffectName("Chant_LifeAura.esf");
				break;

			case 17:
				break;

			case 18:
				DeleteBodyEffectName("Chant_ManaShell2.esf");
				break;
			
			case 19:
				DeleteBodyEffectName("Chant_Encourage.esf");
				break;

			case 20:
				DeleteBodyEffectName("Chant_EnchantWeapon.esf");
				break;

			case 21:
				DeleteBodyEffectName("Chant_BrightArmor.esf");
				break;

			case 22:
				DeleteBodyEffectName("Chant_HardenSkin.esf");
				break;

			case 23:
				DeleteBodyEffectName("Chant_Flexibility.esf");
				break;

			case 24:
				DeleteBodyEffectName("Chant_Guard.esf");
				break;

			case 25:
				DeleteBodyEffectName("Chant_Hold.esf");
				break;

			case 26:
				DeleteBodyEffectName("Chant_Stun.esf");
				break;

			case 27:
				DeleteBodyEffectName("Chant_Frozen.esf");
				break;

			case 28:
				DeleteBodyEffectName("Chant_Poisoned.esf");
				break;

			case 29:
				DeleteBodyEffectName("Chant_LowerStrength.esf");
				break;
		}
		m_dwChant -= (0x00000001 << (dwChant - 1));
	}
}

void CCreature::SetWeaponLine(LPDIRECT3DTEXTURE8 lpTexture,int iColor[3],int iBlend)
{

	m_bWeaponLine = true;
	if(m_pWeaponLine == NULL)
		m_pWeaponLine = new CWeaponLine;

	m_pWeaponLine->m_lpLineTexture = lpTexture;
	m_pWeaponLine->m_iBlend = iBlend;

	if(iColor[0] == -1)
		m_pWeaponLine->m_iColor[0] = rand() % 256;
	else
		m_pWeaponLine->m_iColor[0] = iColor[0];
	if(iColor[1] == -1)
		m_pWeaponLine->m_iColor[1] = rand() % 256;
	else
		m_pWeaponLine->m_iColor[1] = iColor[1];
	if(iColor[2] == -1)
		m_pWeaponLine->m_iColor[2] = rand() % 256;
	else
		m_pWeaponLine->m_iColor[2] = iColor[2];
}
void CCreature::DeleteWeaponLine()
{
	if((m_lpChrModel != NULL) && (m_bWeaponLine == true) && (m_pWeaponLine != NULL)) {

		// WEAPON 슬롯에 들어있는 무기 class Get
		CZ3DWeapon *pWp = m_lpChrModel->GetAttachmentObject( "WEAPON" );

		if(pWp == NULL)	//무기 존재하지 않을때
			return;

		CZ3DBladeTrail* pBladeTrail = pWp->GetBladeTrailInterface();
		
		if( pBladeTrail )
		{	// 초기 검기 복구
			pBladeTrail->SetRGB(255,255,255);		
			pBladeTrail->SetTexture((LPDIRECT3DTEXTURE8)NULL);
			pBladeTrail->SetSecondRenderBlend(D3DBLEND_SRCALPHA, D3DBLEND_ONE );
			
		}
		delete m_pWeaponLine;
		m_pWeaponLine = NULL;
		m_bWeaponLine = false;
	}
	else
	{
		delete m_pWeaponLine;
		m_pWeaponLine = NULL;
		m_bWeaponLine = false;
	}

}
void CCreature::WeaponLineUpdate()
{

	if((m_lpChrModel != NULL) && (m_bWeaponLine == true) && (m_pWeaponLine != NULL)) {
		
		// WEAPON 슬롯에 들어있는 무기 class Get
		CZ3DWeapon *pWp = m_lpChrModel->GetAttachmentObject( "WEAPON" );

		if(pWp == NULL)	//무기 존재하지 않을때
			return;

		CZ3DBladeTrail* pBladeTrail = pWp->GetBladeTrailInterface();
		
		if( pBladeTrail )
		{
			pBladeTrail->SetRGB( m_pWeaponLine->m_iColor[0],		//R
								 m_pWeaponLine->m_iColor[1],		//G
								 m_pWeaponLine->m_iColor[2]);		//B

			if(m_pWeaponLine->m_lpLineTexture != NULL)
				pBladeTrail->SetTexture( m_pWeaponLine->m_lpLineTexture );	// Texture
			else 
				pBladeTrail->SetTexture((LPDIRECT3DTEXTURE8)NULL);
		
			switch(m_pWeaponLine->m_iBlend) {
			case 0:
				pBladeTrail->SetSecondRenderBlend(D3DBLEND_SRCALPHA, D3DBLEND_ONE );
				break;
			case 1:
				pBladeTrail->SetSecondRenderBlend(D3DBLEND_SRCALPHA, D3DBLEND_INVSRCALPHA );
				break;
			case 2:
				pBladeTrail->SetSecondRenderBlend(D3DBLEND_ONE, D3DBLEND_ONE );
				break;
			}

		}
	}
	else
	{
		delete m_pWeaponLine;
		m_pWeaponLine = NULL;
		m_bWeaponLine = false;
	}
}

void CCreature::AddWeaponEffect(char *esfname,int effectnum) 
{

	if(m_lpChrModel != NULL) {
		
		
		/// 무기의 처음과 끝을 알아낸다.
		
		vector3 v1, v2;
		vector3 v3;

		// WEAPON 슬롯에 들어있는 무기 class Get
		CZ3DWeapon *pWp = m_lpChrModel->GetAttachmentObject( "WEAPON" );
		// 처음점, 끝점 얻어낸다. (v1,v2 어떤것이 위의 점인지는 알수 없당)
		//상대좌표이다.
		
		if(pWp == NULL)	//무기 존재하지 않을때
			return;

		pWp->GetMarker( v1, v2 );
		
		///
		
		// 상대좌표이므로 실 좌표는 (무기좌표 + 캐릭터 좌표) 이다.			
		v1 += m_vecPos;
		v2 += m_vecPos;
		v3 = v2 - v1;

		m_bWeaponEffect = true;

		int i;

		
		for( i=0; i<effectnum; i++)						// Add Effect
		{
			
			float veclen = (i+1)/(float)effectnum;

			vector3 lopv1 = v1;
			lopv1 += v3 * veclen;

			CWeaponEffect *node = NULL;
			node = new CWeaponEffect;
			
			// node setting
			node->m_nWeaponEffectNum = effectnum;
			node->m_nWeaponPosNum = i;
			
			strcpy(node->m_strEffect,esfname);
			
			node->m_pEffect = new CEffScript;
			node->m_pEffect->GetScriptData(esfname);
			
			//lopv1 == 이팩트 위치
			node->m_pEffect->SetStartPos( lopv1.x, lopv1.y, lopv1.z );
			node->m_pEffect->SetEndPos( lopv1.x, lopv1.y, lopv1.z );
			
			float fChrDir = m_fDirection = m_lpChrModel->GetDirection();
			fChrDir = -fChrDir;
			fChrDir -= FLOAT_PHI / 2.0f;

			vector3 vecChrToward;
			vecChrToward.x = cosf(fChrDir);
			vecChrToward.z = sinf(fChrDir);	
			vecChrToward.y = 0.0f;
			vecChrToward.Normalize();

			node->m_pEffect->SetChrFwd(-vecChrToward.x,-vecChrToward.y,-vecChrToward.z);

			CSceneManager::m_EffectManager.AddEffScript(node->m_pEffect);
			m_WeaponEffect.push_back(node);

			

		}
	}
}
		
void CCreature::DeleteWeaponEffect()				//전 weapon effect delete
{
	int i;
	
	for( i=0; i < m_WeaponEffect.size(); i++ ) 
	{
		delete m_WeaponEffect[i];
		m_WeaponEffect[i] = NULL;
	}
	m_bWeaponEffect = false;

	m_WeaponEffect.clear();

	
}
void CCreature::DeleteWeaponEffect(char *esfname,int iNum) 	//esfname을 가지는 effect delete
{
	
	int i;
	int iEffNum = iNum;

	for( i = m_WeaponEffect.size() - 1; i >= 0; i-- )
	{
		if(m_WeaponEffect[i] != NULL) {
			if( !CSceneManager::m_EffectManager.CheckNullScript(m_WeaponEffect[i]->m_pEffect) ) 
			{	
				if( !strcmp(esfname,m_WeaponEffect[i]->m_strEffect) ) 
				{
					if(iEffNum)						// 지우는 갯수 한도를 넘지 않는다 
					{
						delete m_WeaponEffect[i];
						m_WeaponEffect[i] = NULL;	
						m_WeaponEffect.erase(&(m_WeaponEffect[i]));
						iEffNum--;
					}
				}
			}
			else 
			{
				delete m_WeaponEffect[i];
				m_WeaponEffect[i] = NULL;	
				m_WeaponEffect.erase(&(m_WeaponEffect[i]));
			}
		}
		else {	
			m_WeaponEffect.erase(&(m_WeaponEffect[i]));
		}
	}

	/*
	for( i=0; i < m_WeaponEffect.size(); i++ ) 
	{
		if( !CSceneManager::m_EffectManager.CheckNullScript(m_WeaponEffect[i]->m_pEffect) ) 
		{	
			if( !strcmp(esfname,m_WeaponEffect[i]->m_strEffect) ) 
			{
				delete m_WeaponEffect[i];
				m_WeaponEffect[i] = NULL;	
				m_WeaponEffect.erase(&(m_WeaponEffect[i]));
			}
		}
		else 
		{
			delete m_WeaponEffect[i];
			m_WeaponEffect[i] = NULL;	
			m_WeaponEffect.erase(&(m_WeaponEffect[i]));
		}
	}
	*/
	if(m_WeaponEffect.size() <= 0) 
	{
		m_bWeaponEffect = false;
		m_WeaponEffect.clear();
	}

}

void CCreature::WeaponEffectUpdate()
{
	int i;

	
	if(m_bWeaponEffect)								//등록된 Weapon Effect 가 있을때
	{
		if(m_lpChrModel) {

			/// 무기의 처음과 끝을 알아낸다.
			
			vector3 v1, v2;
			vector3 v3;

			// WEAPON 슬롯에 들어있는 무기 class Get
			CZ3DWeapon *pWp = m_lpChrModel->GetAttachmentObject( "WEAPON" );
			
			if(pWp == NULL) {	//캐릭터가 무기 않들었을시에 weapon effect 전체 삭제
				DeleteWeaponEffect();
				return;
			}
			// 처음점, 끝점 얻어낸다. (v1,v2 어떤것이 위의 점인지는 알수 없당)
			//상대좌표이다.
			pWp->GetMarker( v1, v2 );
			
			
			///
			
			// 상대좌표이므로 실 좌표는 (무기좌표 + 캐릭터 좌표) 이다.			
			v1 += m_vecPos;
			v2 += m_vecPos;
			v3 = v2 - v1;

			if( m_WeaponEffect.size() > 0 ) {
				for( i=0; i < m_WeaponEffect.size(); i++ ) 
				{
					
					if(m_WeaponEffect[i] != NULL) 
					{
					float veclen = (m_WeaponEffect[i]->m_nWeaponPosNum + 1) / (float)(m_WeaponEffect[i]->m_nWeaponEffectNum + 1);
					
					vector3 lopv1 = v1;
					lopv1 += v3 * veclen;
					//lopv1이 Update 될 effect의 위치
					// 6. 16일 Update 
					if(m_WeaponEffect[i]->m_pEffect != NULL && !(CSceneManager::m_EffectManager.CheckNullScript(m_WeaponEffect[i]->m_pEffect))){
							m_WeaponEffect[i]->m_pEffect->SetStartPos(lopv1.x,lopv1.y,lopv1.z);
							m_WeaponEffect[i]->m_pEffect->SetEndPos(lopv1.x,lopv1.y,lopv1.z);
							
							float fChrDir = m_fDirection = m_lpChrModel->GetDirection();
							fChrDir = -fChrDir;
							fChrDir -= FLOAT_PHI / 2.0f;

							vector3 vecChrToward;
							vecChrToward.x = cosf(fChrDir);
							vecChrToward.z = sinf(fChrDir);	
							vecChrToward.y = 0.0f;
							vecChrToward.Normalize();

							m_WeaponEffect[i]->m_pEffect->SetChrFwd(-vecChrToward.x,-vecChrToward.y,-vecChrToward.z);


						}
						else 
						{
							delete m_WeaponEffect[i];
							m_WeaponEffect[i] = NULL;	
							m_WeaponEffect.erase(&(m_WeaponEffect[i]));
						}
					}
					else 
					{	
						m_WeaponEffect.erase(&(m_WeaponEffect[i]));
					}
				}										//for
			}											//if( m_WeaponEffect.size() > 0 )
			else 
			{
				m_WeaponEffect.clear();
				m_bWeaponEffect = false;
			}
		}//if(m_lpChrModel)
		else {
			DeleteWeaponEffect();
		}
	}
}