//タンク頭と照準の角度（上下）
void For_b(Tank(&tank)[myTANKNUM], float pitchmax, float pitchmin)
{
D3DXVECTOR3 m_vec;
D3DXVECTOR3 m_gun;
D3DXVECTOR3 m_pos;
D3DXVECTOR3 m_lookat;
float m_val;
D3DXVec3Subtract(&m_vec, &camera.m_pos, &camera.m_lookat);
m_pos = { camera.m_pos.x, 0.f, camera.m_pos.z };
m_lookat = { camera.m_lookat.x, 0.f, camera.m_lookat.z };
D3DXVec3Subtract(&m_gun, &m_pos, &m_lookat);
D3DXVec3Normalize(&m_vec, &m_vec);
D3DXVec3Normalize(&m_gun, &m_gun);
m_val = D3DXVec3Dot(&m_vec, &m_gun);
if (camera.m_pos.y < tank[myBODY].position.y)
{
tank[myGUN].b = -D3DXToDegree(acos(m_val));
if (tank[myGUN].b <= -pitchmax) tank[myGUN].b = -pitchmax;
}
else if (camera.m_pos.y >= tank[myBODY].position.y)
{
tank[myGUN].b = D3DXToDegree(acos(m_val));
if (tank[myGUN].b >= pitchmin) tank[myGUN].b = pitchmin;
}
}
//敵頭とタンクの角度（上下）
void For_d(Enemy(&enemy)[eTANKNUM], Tank(&tank)[myTANKNUM], float pitchmax, float pitchmin)
{
D3DXVECTOR3 emy_ply;
D3DXVECTOR3 emy_y0;
D3DXVECTOR3 x;
float e_val;
x = { 0.f, 2.f, 0.f };
emy_ply = enemy[eBODY].position - (tank[myBODY].position - x);
emy_y0 = { emy_ply.x, 0.f, emy_ply.z };
D3DXVec3Normalize(&emy_ply, &emy_ply);
D3DXVec3Normalize(&emy_y0, &emy_y0);
e_val = D3DXVec3Dot(&emy_ply, &emy_y0);
if (enemy[eBODY].position.y <= (tank[myBODY].position.y - 2.f))
{
enemy[eGUN].d = -D3DXToDegree(acos(e_val)) / 3.f;
if (enemy[eGUN].d <= -pitchmax) enemy[eGUN].d = -pitchmax;
}
else if (enemy[eBODY].position.y > (tank[myBODY].position.y - 2.f))
{
enemy[eGUN].d = D3DXToDegree(acos(e_val)) / 3.f;
if (enemy[eGUN].d >= pitchmin) enemy[eGUN].d = pitchmin;
}
}
void CameraClass::SetYPR(float x, float y, float z)
{
Yaw +=(x/5)*0.0174532925f;
Pitch -=(y/5)*0.0174532925f;
Roll -=(z/5)*0.0174532925f;
m_rotationX = D3DXToDegree(Pitch);///0.0174532925f;
m_rotationY = D3DXToDegree(Yaw);
m_rotationZ = D3DXToDegree(Roll);
}
//----[ combineSRT ]---------------------------------------------------------
void Mesh::combineSRT(float sx, float sy, float sz,
float rx, float ry, float rz,
float tx, float ty, float tz) {
scaling_.getX()->setValue(scaling_.getX()->getValue() * sx);
scaling_.getY()->setValue(scaling_.getY()->getValue() * sy);
scaling_.getZ()->setValue(scaling_.getZ()->getValue() * sz);
rotation_.getX()->setValue(rotation_.getX()->getValue() + D3DXToDegree(rx));
rotation_.getY()->setValue(rotation_.getY()->getValue() + D3DXToDegree(ry));
rotation_.getZ()->setValue(rotation_.getZ()->getValue() + D3DXToDegree(rz));
translation_.getX()->setValue(translation_.getX()->getValue() + tx);
translation_.getY()->setValue(translation_.getY()->getValue() + ty);
translation_.getZ()->setValue(translation_.getZ()->getValue() + tz);
}
void CNormalEnemy_3_2Point::Shot()
{
if(!m_bShot)
{
m_bShot =true;
CTaskIter i(Game->MyShipList);
if(i.HasNext())
{
CGameObj *obj =(CGameObj*)i.Next();
to_X =obj->X;
to_Y =obj->Y;
}
}
if(!m_angle)
m_angle =D3DXToDegree(atan2(to_X-X,to_Y-Y));
if(m_shot_count<=0)
{
m_shot_count =m_shot_count2;
if(m_shot_num<m_max_shot_num)
{
++m_shot_num;
Game->sound[0]->Play();
for(int i=0;i<m_shot_num;++i)
{
new CEnemyBullet(X,Y,m_angle+(i*5.0f)-((m_shot_num-1)*5.0f)/2,m_shot_speed,30.0f,0.05f,0xff33ff00);
new CEnemyBullet(X,Y,m_angle+180+(i*5.0f)-((m_shot_num-1)*5.0f)/2,m_shot_speed,30.0f,0.05f,0xff33ff00);
}
}
}
--m_shot_count;
}
void ShadowBeast::ShadowArm::shoot()
{
auto billposition = ((Stage3*)SceneManager::getInstance()->getCurrentScene())->getBill()->getPosition();
auto thisPosition = _arm._sprite->getPosition();
auto angle_tracked = atan((billposition.x - thisPosition.x) / (thisPosition.y - billposition.y ));
BulletManager::insertBullet(new BeastBullet(_arm._sprite->getPosition(), D3DXToDegree(- angle_tracked - M_PI)));
}
//敵頭と敵タンクの角度（左右）
void For_e(Enemy(&enemy)[eTANKNUM])
{
D3DXVECTOR3 emy_pot;
D3DXVECTOR3 x0;
float p_val;
emy_pot = enemy[eBODY].position - Point.position;
x0 = { 0.f, 0.f, 1.f };
D3DXVec3Normalize(&emy_pot, &emy_pot);
p_val = D3DXVec3Dot(&emy_pot, &x0);
if (enemy[eBODY].position.x <= Point.position.x) enemy[eBODY].e = 180.f - D3DXToDegree(acos(p_val));
else if (enemy[eBODY].position.x > Point.position.x) enemy[eBODY].e = -180.f + D3DXToDegree(acos(p_val));
if (enemy[eBODY].e >= 360.f) enemy[eBODY].e -= 360.f;
if (enemy[eBODY].e <= -360.f) enemy[eBODY].e += 360.f;
}
void ShadowBeast::ShadowMouth::shoot()
{
BulletManager::insertBullet(new BeastBullet(this->getPosition() + GVector2(- 32, -32), D3DXToDegree( M_PI + M_PI_2 / 3)));
BulletManager::insertBullet(new BeastBullet(this->getPosition() + GVector2(0, -32), D3DXToDegree(M_PI + 0)));
BulletManager::insertBullet(new BeastBullet(this->getPosition() + GVector2(+ 32, -32), D3DXToDegree(M_PI - M_PI_2 / 3)));
_flagCanShoot = false;
}
void CDofEditing::UpdateAngles(void)
{
CString Angle;
Angle.Format("%05.2f", D3DXToDegree(m_Yaw));
m_YawAngle.SetWindowText(Angle);
Angle.Format("%05.2f", D3DXToDegree(m_Pitch));
m_PitchAngle.SetWindowText(Angle);
Angle.Format("%05.2f", D3DXToDegree(m_Roll));
m_RollAngle.SetWindowText(Angle);
D3DXMatrixRotationYawPitchRoll(&m_Dof->dof.rotation, m_Yaw, m_Pitch, m_Roll);
Angle.Format("%7.3f", m_Dof->dof.translation.x);
m_XPos.SetWindowText(Angle);
Angle.Format("%7.3f", m_Dof->dof.translation.y);
m_YPos.SetWindowText(Angle);
Angle.Format("%7.3f", m_Dof->dof.translation.z);
m_ZPos.SetWindowText(Angle);
Angle.Format("%7.3f", m_Dof->dof.scale.x);
m_XScale.SetWindowText(Angle);
Angle.Format("%7.3f", m_Dof->dof.scale.y);
m_YScale.SetWindowText(Angle);
Angle.Format("%7.3f", m_Dof->dof.scale.z);
m_ZScale.SetWindowText(Angle);
Angle.Format("%7.3f", m_Dof->dof.multiplier);
m_DofCx.SetWindowText(Angle);
m_DofInvCheck.SetCheck(m_Dof->dof.flags&XDOF_NEGATE);
m_DofLimits.SetCheck(m_Dof->dof.flags&XDOF_MINMAX);
m_DofDegrees.SetCheck(m_Dof->dof.flags&XDOF_ISDOF);
m_DofScale.SetCheck(m_Dof->dof.flags&XDOF_SUBRANGE);
Angle.Format("%7.3f", (m_Dof->dof.flags&XDOF_ISDOF)?D3DXToDegree(m_Dof->dof.max):m_Dof->dof.max);
m_DofMax.SetWindowText(Angle);
Angle.Format("%7.3f", (m_Dof->dof.flags&XDOF_ISDOF)?D3DXToDegree(m_Dof->dof.min):m_Dof->dof.min);
m_DofMin.SetWindowText(Angle);
CString Caption;
Caption.Format("DOF Nr : %03d", m_Dof->dof.dofNumber);
SetWindowText(Caption);
m_DofList.SetCurSel(m_Dof->dof.Type);
}
void CObjectTool::OnInfoReset()
{
// TODO: 여기에 컨트롤 알림 처리기 코드를 추가합니다.
if (m_pCurObject)
{
const CComponent* pComponent = m_pCurObject->GetComponent(L"Transform");
m_fEditScaleX = ((CInfo*)pComponent)->m_vScale.x;
m_fEditScaleY = ((CInfo*)pComponent)->m_vScale.y;
m_fEditScaleZ = ((CInfo*)pComponent)->m_vScale.z;
m_fEditAngleX = ((CInfo*)pComponent)->m_fAngle[ANGLE_X];
m_fEditAngleY = ((CInfo*)pComponent)->m_fAngle[ANGLE_Y];
m_fEditAngleZ = ((CInfo*)pComponent)->m_fAngle[ANGLE_Z];
m_fEditAngleX = D3DXToDegree(m_fEditAngleX);
m_fEditAngleY = D3DXToDegree(m_fEditAngleY);
m_fEditAngleZ = D3DXToDegree(m_fEditAngleZ);
m_fEditPosX = ((CInfo*)pComponent)->m_vPos.x;
m_fEditPosY = ((CInfo*)pComponent)->m_vPos.y;
m_fEditPosZ = ((CInfo*)pComponent)->m_vPos.z;
//m_PotentialCollision.SetCheck(((Engine::CTransform*)pComponent)->m_bCollision);
//m_stCurrentMeshKey = ((Engine::CTransform*)pComponent)->m_tcKey;
}
else
{
m_fEditScaleX = 0.f;
m_fEditScaleY = 0.f;
m_fEditScaleZ = 0.f;
m_fEditAngleX = 0.f;
m_fEditAngleY = 0.f;
m_fEditAngleZ = 0.f;
m_fEditPosX = 0.f;
m_fEditPosY = 0.f;
m_fEditPosZ = 0.f;
//m_PotentialCollision.SetCheck(FALSE);
}
UpdateData(FALSE);
}
CCamera* CObject_Player::OnChangeCamera(ID3D11Device *pd3dDevice, DWORD nNewCameraMode, DWORD nCurrentCameraMode)
{
CCamera *pNewCamera = NULL;
//새로운 카메라의 모드에 따라 카메라를 새로 생성한다.
switch (nNewCameraMode)
{
case FIRST_PERSON_CAMERA:
pNewCamera = new CFirstPersonCamera(m_pCamera);
break;
case THIRD_PERSON_CAMERA:
pNewCamera = new CThirdPersonCamera(m_pCamera);
break;
case SPACESHIP_CAMERA:
pNewCamera = new CSpaceShipCamera(m_pCamera);
break;
}
/*현재 카메라의 모드가 스페이스-쉽 모드의 카메라이고 새로운 카메라가 1인칭 또는 3인칭 카메라이면
플레이어의 Up 벡터를 월드좌표계의 y-축 방향 벡터(0, 1, 0)이 되도록 한다. 즉, 똑바로 서도록 한다.
그리고 스페이스-쉽 카메라의 경우 플레이어의 이동에는 제약이 없다. 특히, y-축 방향의 움직임이 자유롭다.
그러므로 플레이어의 위치는 공중(위치 벡터의 y-좌표가 0보다 크다)이 될 수 있다.
이때 새로운 카메라가 1인칭 또는 3인칭 카메라이면 플레이어의 위치는 지면이 되어야 한다.
그러므로 플레이어의 Right 벡터와 Look 벡터의 y 값을 0으로 만든다. 이제 플레이어의 Right 벡터와 Look 벡터는 단위벡터가 아니므로 정규화한다.*/
if (nCurrentCameraMode == SPACESHIP_CAMERA)
{
m_d3dxvUp = D3DXVECTOR3(0.0f, 1.0f, 0.0f);
m_d3dxvRight.y = 0.0f;
m_d3dxvLook.y = 0.0f;
D3DXVec3Normalize(&m_d3dxvRight, &m_d3dxvRight);
D3DXVec3Normalize(&m_d3dxvLook, &m_d3dxvLook);
m_fPitch = 0.0f;
m_fRoll = 0.0f;
/*Look 벡터와 월드좌표계의 z-축(0, 0, 1)이 이루는 각도(내적=cos)를 계산하여 플레이어의 y-축의 회전 각도 m_fYaw로 설정한다.*/
m_fYaw = (float)D3DXToDegree(acosf(D3DXVec3Dot(&D3DXVECTOR3(0.0f, 0.0f, 1.0f), &m_d3dxvLook)));
if (m_d3dxvLook.x < 0.0f) m_fYaw = -m_fYaw;
}
else if ((nNewCameraMode == SPACESHIP_CAMERA) && m_pCamera)
{
/*새로운 카메라의 모드가 스페이스-쉽 모드의 카메라이고 현재 카메라 모드가 1인칭 또는 3인칭 카메라이면 플레이어의 로컬 축을 현재 카메라의 로컬 축과 같게 만든다.*/
m_d3dxvRight = m_pCamera->GetRightVector();
m_d3dxvUp = m_pCamera->GetUpVector();
m_d3dxvLook = m_pCamera->GetLookVector();
}
if (pNewCamera)
{
//기존 카메라가 없으면 새로운 카메라를 위한 쉐이더 변수를 생성한다.
if (!m_pCamera) pNewCamera->CreateShaderVariables(pd3dDevice);
pNewCamera->SetMode(nNewCameraMode);
//현재 카메라를 사용하는 플레이어 객체를 설정한다.
pNewCamera->SetPlayer(this);
}
if (m_pCamera) delete m_pCamera;
return(pNewCamera);
}
//タンク頭と照準の角度（左右）
void For_a(Tank(&tank)[myTANKNUM])
{
D3DXVECTOR3 m_vec;
D3DXVECTOR3 m_head;
D3DXVECTOR3 m_pos;
D3DXVECTOR3 m_lookat;
float m_val;
m_pos = { camera.m_pos.x, 0.f, camera.m_pos.z };
m_lookat = { camera.m_lookat.x, 0.f, camera.m_lookat.z };
m_head = { 0.f, 0.f, 1.f };
D3DXVec3Subtract(&m_vec, &m_pos, &m_lookat);
D3DXVec3Normalize(&m_vec, &m_vec);
D3DXVec3Normalize(&m_head, &m_head);
m_val = D3DXVec3Dot(&m_vec, &m_head);
if (camera.m_curpt.x >= 960 && camera.m_curpt.x <= 1884) tank[myHEAD].a = 180.f - D3DXToDegree(acos(m_val));
else if (camera.m_curpt.x >= 0 && camera.m_curpt.x < 960) tank[myHEAD].a = -180.f + D3DXToDegree(acos(m_val));
if (tank[myHEAD].a >= 360.f) tank[myHEAD].a -= 360.f;
if (tank[myHEAD].a <= -360.f) tank[myHEAD].a += 360.f;
}
float NEW_GetSignedDegreeFromDirPixelPosition(const TPixelPosition& kPPosDir)
{
D3DXVECTOR3 vtDir(kPPosDir.x, -kPPosDir.y, kPPosDir.z);
D3DXVECTOR3 vtDirNormal;
D3DXVec3Normalize(&vtDirNormal, &vtDir);
D3DXVECTOR3 vtDirNormalStan(0, -1, 0);
float fDirRot = D3DXToDegree(acosf(D3DXVec3Dot(&vtDirNormal, &vtDirNormalStan)));
if (vtDirNormal.x<0.0f)
fDirRot=-fDirRot;
return fDirRot;
}
static void GetAngleFromPoint(float x1, float y1, float z1, float x2, float y2, float z2, float* ax, float* ay, float* az)
{
D3DXVECTOR3 Vector;
Vector.x = x2-x1;
Vector.y = y2-y1;
Vector.z = z2-z1;
// Find Y and then X axis rotation
double yangle=atan2(Vector.x, Vector.z);
if(yangle<0.0) yangle+=D3DXToRadian(360.0);
if(yangle>=D3DXToRadian(360.0)) yangle-=D3DXToRadian(360.0);
D3DXMATRIX yrotate;
D3DXMatrixRotationY ( &yrotate, (float)-yangle );
D3DXVec3TransformCoord ( &Vector, &Vector, &yrotate );
double xangle=-atan2(Vector.y, Vector.z);
if(xangle<0.0) xangle+=D3DXToRadian(360.0);
if(xangle>=D3DXToRadian(360.0)) xangle-=D3DXToRadian(360.0);
*ax = wrapangleoffset(D3DXToDegree((float)xangle));
*ay = wrapangleoffset(D3DXToDegree((float)yangle));
*az = 0.0f;
}
void CDofEditing::EditDof(E_Object *Object, DXDof *Dof)
{
m_Dof=Dof;
m_OriginalDof=Dof->dof;
m_Object=Object;
if(!m_Object) {
ShowWindow(SW_HIDE);
return;
}
m_DofList.SetCurSel(2);
m_DofSlider.SetPos((int)D3DXToDegree((float)m_Object->Obj->DOFValues[m_Dof->dof.dofNumber].rotation));
ShowWindow(SW_SHOW);
GetOriginalAngles();
UpdateAngles();
}
void Camera::lookAt(const D3DXVECTOR3 &eye, const D3DXVECTOR3 &target, const D3DXVECTOR3 &up)
{
m_eye = eye;
m_zAxis = target - eye;
D3DXVec3Normalize(&m_zAxis, &m_zAxis);
m_viewDir = m_zAxis;
D3DXVec3Cross(&m_xAxis, &up, &m_zAxis);
D3DXVec3Normalize(&m_xAxis, &m_xAxis);
D3DXVec3Cross(&m_yAxis, &m_zAxis, &m_xAxis);
D3DXVec3Normalize(&m_yAxis, &m_yAxis);
D3DXVec3Normalize(&m_xAxis, &m_xAxis);
D3DXMatrixIdentity(&m_viewMatrix);
m_viewMatrix(0,0) = m_xAxis.x;
m_viewMatrix(1,0) = m_xAxis.y;
m_viewMatrix(2,0) = m_xAxis.z;
m_viewMatrix(3,0) = -D3DXVec3Dot(&m_xAxis, &eye);
m_viewMatrix(0,1) = m_yAxis.x;
m_viewMatrix(1,1) = m_yAxis.y;
m_viewMatrix(2,1) = m_yAxis.z;
m_viewMatrix(3,1) = -D3DXVec3Dot(&m_yAxis, &eye);
m_viewMatrix(0,2) = m_zAxis.x;
m_viewMatrix(1,2) = m_zAxis.y;
m_viewMatrix(2,2) = m_zAxis.z;
m_viewMatrix(3,2) = -D3DXVec3Dot(&m_zAxis, &eye);
// Extract the pitch angle from the view matrix.
m_accumPitchDegrees = D3DXToDegree(-asinf(m_viewMatrix(1,2)));
}
//敵頭とタンクの角度（左右）
void For_c(Enemy(&enemy)[eTANKNUM], Tank(&tank)[myTANKNUM])
{
D3DXVECTOR3 emy_ply;
D3DXVECTOR3 emy_z;
float e_val;
emy_ply = enemy[eBODY].position - tank[myBODY].position;
emy_z = { 0.f, 0.f, 1.f };
D3DXVec3Normalize(&emy_ply, &emy_ply);
D3DXVec3Normalize(&emy_z, &emy_z);
e_val = D3DXVec3Dot(&emy_ply, &emy_z);
if (enemy[eBODY].position.x <= tank[myBODY].position.x) enemy[eHEAD].c = 180.f - D3DXToDegree(acos(e_val));
else if (enemy[eBODY].position.x > tank[myBODY].position.x) enemy[eHEAD].c = -180.f + D3DXToDegree(acos(e_val));
if (enemy[eHEAD].c >= 360.f) enemy[eHEAD].c -= 360.f;
if (enemy[eHEAD].c <= -360.f) enemy[eHEAD].c += 360.f;
}
bool BuildAreaBuilder::BuildCheck(bool _roadLinkStart_StartPos, bool _roadLinkEnd_StartPos)
{
if (m_StartPosLink)
{
if (m_roadStartAngle < 0)
{
m_roadStartAngle = 360.f + m_roadStartAngle;
}
float roadAngle;
if (_roadLinkStart_StartPos)
{
//繋げられている道のStartPosからの場合、指定座標のEndPosからStartPosの角度を取らないと行けない、EndPosの場合反対
roadAngle = D3DXToDegree(atan2(m_StartPos.z - m_EndPos.z, m_StartPos.x - m_EndPos.x));
}
else
{
roadAngle = D3DXToDegree(atan2(m_EndPos.z - m_StartPos.z, m_EndPos.x - m_StartPos.x));
}
if (roadAngle < 0)
{
roadAngle = 360.f + roadAngle;
}
m_roadStartAngle = m_roadStartAngle - roadAngle;
}
if (m_EndPosLink)
{
if (m_roadEndAngle < 0)
{
m_roadEndAngle = 360.f + m_roadEndAngle;
}
float roadAngle;
if (_roadLinkEnd_StartPos)
{
roadAngle = D3DXToDegree(atan2(m_EndPos.z - m_StartPos.z, m_EndPos.x - m_StartPos.x));
}
else
{
//繋げられている道のEndPosからの場合、指定座標のEndPosからStartPosの角度を取らないと行けない、EndPosの場合反対
roadAngle = D3DXToDegree(atan2(m_StartPos.z - m_EndPos.z, m_StartPos.x - m_EndPos.x));
}
if (roadAngle < 0)
{
roadAngle = 360.f + roadAngle;
}
m_roadEndAngle = roadAngle - m_roadEndAngle;
}
bool roadStartAngleOver = BuildAngleCheck(m_roadStartAngle);
bool roadEndAngleOver = BuildAngleCheck(m_roadEndAngle);
//道が90度以上の急な道は作れない
if (roadStartAngleOver && m_StartPosLink &&
roadEndAngleOver && m_EndPosLink ||
m_StartPosLink == false && m_EndPosLink == false)
{
return true;
}
else if (roadStartAngleOver && m_StartPosLink && m_EndPosLink == false ||
roadEndAngleOver && m_EndPosLink && m_StartPosLink == false)
{
return true;
}
else
{
return false;
}
}
//
// 오브젝트를 움직이는데 필요한 메시지를 발생
//
int CWndWorld::ControlGround( DWORD dwMessage, CPoint point )
{
bool fCastCancel = false;
int nMsg = 0;
BOOL bTempKey, bSit; // ,bCombatKey, bFlyKey
BOOL bUp, bDown, bLeft, bRight, bSpace, bBoard, bLForward = FALSE, bRForward = FALSE;
BOOL bWalk;
static BOOL s_bWalk2 = 0;
CMover* pMover = CMover::GetActiveMover();
CWndChat* pWndChat = (CWndChat*) g_WndMng.GetApplet( APP_COMMUNICATION_CHAT );
BOOL bWhisper = g_bKeyTable['R'];
if( pWndChat && bWhisper )
{
if( 0 < strlen( g_Neuz.m_szWhisperName ) )
{
CString strWhisper;
strWhisper.Format( "/whisper %s ", g_Neuz.m_szWhisperName );
pWndChat->SetFocus();
CWndEditChat* pWndEdit = &pWndChat->m_wndEdit;
pWndEdit->SetString( strWhisper );
pWndEdit->SetFocus();
g_bKeyTable['R'] = FALSE;
}
}
// 전진/후진/스톱
CWndBase* pWndBaseFocus = (CWndBase*) g_WndMng.GetFocusWnd();
if( g_Neuz.m_bActiveNeuz == FALSE || ( pWndChat && pWndBaseFocus && pWndBaseFocus == pWndChat ) )
{
g_bKeyTable[g_Neuz.Key.chUp] = FALSE;// | m_bRButtonDown;
g_bKeyTable[g_Neuz.Key.chLeft] = FALSE;
g_bKeyTable['S'] = FALSE;
g_bKeyTable['D'] = FALSE;
g_bKeyTable['Q'] = FALSE;
g_bKeyTable['E'] = FALSE;
}
bUp = g_bKeyTable[g_Neuz.Key.chUp]; // | m_bRButtonDown;
bDown = g_bKeyTable['S'];
#ifdef __BS_ADJUST_SYNC
//gmpbigsun : 키보드 조작중에는 마우스이동 불가
if( bUp || bDown )
m_bLButtonDown = FALSE;
#endif
if( bDown )
{
g_WndMng.m_bAutoRun = FALSE;
}
if( bUp )
{
m_timerAutoRunPush.Reset();
if( m_nDubleUp == 2 && m_timerAutoRun.TimeOut() == FALSE )
{
m_nDubleUp = 3;
g_WndMng.m_bAutoRun = TRUE;
m_timerAutoRun.Reset();
m_timerAutoRunBlock.Reset();
}
else
{
m_nDubleUp = 1;
m_timerAutoRun.Reset();
}
if( m_timerAutoRunBlock.TimeOut() )
g_WndMng.m_bAutoRun = FALSE;
}
else
{
if( m_timerAutoRunPush.TimeOut() == FALSE )
{
if( m_nDubleUp == 1 )
m_nDubleUp = 2;
}
else
{
m_nDubleUp = 0;
}
}
if( g_WndMng.m_bAutoRun )
bUp = TRUE;
// 좌/우 회전
bLeft = g_bKeyTable[g_Neuz.Key.chLeft];
bRight = g_bKeyTable['D'];
bSpace = g_bKeyTable[ VK_SPACE ];
// bCombatKey = g_bKeyTable['C'];
// g_bKeyTable['C'] = 0;
bBoard = g_bKeyTable['B'];
bSit = g_bKeyTable['V'];
g_bKeyTable['V'] = 0;
/*
if( g_Option.m_nInterface == 2 )
{
bLForward = g_bKeyTable['Q'];
bRForward = g_bKeyTable['E'];
if( m_bLButtonDown )
{
if( bLeft )
{
bLeft = FALSE;
bLForward = TRUE;
}
if( bRight )
{
bRight = FALSE;
bRForward = TRUE;
}
}
}
*/
CWorld* pWorld = g_WorldMng.Get();
CRect rect = GetClientRect();
D3DXVECTOR3 vRayEnd;
CObj* pFocusObj = pWorld->GetObjFocus();
CActionMover *pAct = pMover->m_pActMover;
pAct->m_dwCtrlMsg = 0;
if( m_bLButtonDown )
pAct->m_dwCtrlMsg |= CTRLMSG_LDOWN;
#if __VER >= 12 // __ITEMCREATEMON_S0602
D3DXVECTOR3 vec3Tri[3];
pWorld->ClientPointToVector( vec3Tri, rect, point, &pWorld->m_matProj, &g_Neuz.m_camera.m_matView, &vRayEnd, TRUE );
g_Neuz.m_vCursorPos = vRayEnd;
if( g_Neuz.m_pCreateMonItem )
{
if( bUp || bDown || bLeft || bRight || bSpace || m_bLButtonDown )
{
BOOL bSendCM = TRUE;
if( m_bLButtonDown )
{
D3DXVECTOR3 vDist2 = g_pPlayer->GetPos() - g_Neuz.m_vCursorPos;
float fDist = D3DXVec3Length( &vDist2 ); // 두좌표간의 거리
if( 15.f < fDist )
{
g_WndMng.PutString( prj.GetText( TID_GAME_CREATEMON_F_15 ), NULL, prj.GetTextColor( TID_GAME_CREATEMON_F_15 ) );
bSendCM = FALSE;
}
if( bSendCM )
{
int nAttr = g_pPlayer->GetWorld()->GetHeightAttribute( g_Neuz.m_vCursorPos.x, g_Neuz.m_vCursorPos.z ); // 이동할 위치의 속성 읽음.
if( nAttr == HATTR_NOWALK || nAttr == HATTR_NOMOVE
|| g_pPlayer->IsRegionAttr( RA_SAFETY ) || g_pPlayer->GetWorld()->GetID() == WI_WORLD_GUILDWAR ) // 못 움직이는 곳이거나 안전지역이면 Pass
{
g_WndMng.PutString( prj.GetText( TID_GAME_CREATEMON_F_AREA ), NULL, prj.GetTextColor( TID_GAME_CREATEMON_F_AREA ) );
bSendCM = FALSE;
}
else
if( g_pPlayer->GetWorld()->GetID() != WI_WORLD_MADRIGAL )
{
g_WndMng.PutString( prj.GetText( TID_GAME_CREATEMON_F_AREA ), NULL, prj.GetTextColor( TID_GAME_CREATEMON_F_AREA ) );
bSendCM = FALSE;
}
if( bSendCM )
{
g_DPlay.SendCreateMonster( MAKELONG( ITYPE_ITEM, g_Neuz.m_pCreateMonItem->m_dwObjId ), g_Neuz.m_vCursorPos );
}
}
m_bLButtonDown = FALSE;
}
if( bSendCM )
g_Neuz.m_pCreateMonItem = NULL;
}
}
#endif // __ITEMCREATEMON_S0602
//TODO:ata3k님 꼭 고쳐주세요. 왜 그런지 아무도 몰라!
// 이동금지 상태가 아닐때만 클릭으로 이동할수 있다.
#ifdef __Y_INTERFACE_VER3
bool *bpButton;
if( g_Option.m_nInterface == 2 )
bpButton = &m_bLButtonUp;
else
bpButton = &m_bLButtonDown;
if( *bpButton )
#else //__Y_INTERFACE_VER3
if( m_bLButtonDown )
#endif //__Y_INTERFACE_VER3
{
#ifdef __Y_INTERFACE_VER3
if( g_Option.m_nInterface == 2 )
{
*bpButton = FALSE;
if( m_timerLButtonDown.GetLeftTime() > 200 )
return nMsg;
}
#endif //__Y_INTERFACE_VER3
D3DXVECTOR3 vec3Tri[3];
if( pWorld->ClientPointToVector( vec3Tri, rect, point, &pWorld->m_matProj, &g_Neuz.m_camera.m_matView, &vRayEnd, TRUE ) )
{
// 이동 포인트를 얻어 목표 세팅
if( m_bFreeMove )
{
// if( m_bLButtonDown ) // 이동금지 상태가 아닐때만 클릭으로 이동할수 있다.
{
{
if( m_pWndGuideSystem && m_pWndGuideSystem->IsVisible())
#if __VER >= 12 // __MOD_TUTORIAL
m_pWndGuideSystem->m_Condition.bIsClickOnLand = true;
#else
m_pWndGuideSystem->SendGuideMessage(GUIDE_EVENT_MOVE);
#endif
#ifdef __IAOBJ0622
if( GetLastPickObj() && GetLastPickObj()->GetType() == OT_SHIP )
pMover->SetDestPos( (CShip *)GetLastPickObj(), vRayEnd );
else
pMover->SetDestPos( vRayEnd );
#else
pMover->SetDestPos( vRayEnd );
#endif
pMover->m_nCorr = -1;
#ifndef __J0823
m_bFreeMove = FALSE;
g_DPlay.SendSnapshot( TRUE );
fCastCancel = true;
if( g_pMoveMark && g_pMoveMark->m_pSfxObj )
g_pMoveMark->m_pSfxObj->m_nCurFrame = 180;
CSfx *pObj = CreateSfx(g_Neuz.m_pd3dDevice,XI_GEN_MOVEMARK01,vRayEnd);
D3DXVECTOR3 vVector1 = vec3Tri[2] - vec3Tri[0];
D3DXVECTOR3 vVector2 = vec3Tri[1] - vec3Tri[0];
D3DXVECTOR3 vNormal;
D3DXVec3Cross( &vNormal, &vVector1, &vVector2);
D3DXVec3Normalize( &vNormal, &vNormal );
D3DXVECTOR3 v3Up = D3DXVECTOR3( 0.0f, -1.0f, 0.0f );
D3DXVECTOR3 v3Cross;
FLOAT fDot;
FLOAT fTheta;
D3DXVec3Cross( &v3Cross, &v3Up, &vNormal );
fDot = D3DXVec3Dot( &v3Up, &vNormal );
fTheta = acos( fDot );
D3DXQUATERNION qDirMap;
D3DXQuaternionRotationAxis( &qDirMap, &v3Cross, fTheta );
D3DXVECTOR3 vYPW;
QuaternionRotationToYPW( qDirMap, vYPW );
pObj->m_pSfxObj->m_vRotate.x = D3DXToDegree(vYPW.x);
pObj->m_pSfxObj->m_vRotate.y = D3DXToDegree(vYPW.y);
pObj->m_pSfxObj->m_vRotate.z = D3DXToDegree(vYPW.z);
#endif // __J0823
m_objidTracking = NULL_ID;
}
}
}
}
}
//if( !pMover->IsEmptyDestPos() || !pMover->IsEmptyDestObj() )
// return nMsg;
#ifdef __Y_INTERFACE_VER3
if( bUp || bDown || bLeft || bRight || bSpace || bLForward || bRForward ) // 이동 키조작이 들어가면 자동공격 멈춤.
#else //__Y_INTERFACE_VER3
if( bUp || bDown || bLeft || bRight || bSpace ) // 이동 키조작이 들어가면 자동공격 멈춤.
#endif //__Y_INTERFACE_VER3
{
if( bUp || bDown )
#if __VER >= 12 // __MOD_TUTORIAL
{
CWndGuideSystem* pWndGuide = NULL;
pWndGuide = (CWndGuideSystem*)GetWndBase( APP_GUIDE );
if(pWndGuide && pWndGuide->IsVisible()) pWndGuide->m_Condition.bIsKeyMove = true;
}
#else
m_pWndGuideSystem->SendGuideMessage(GUIDE_EVENT_KEY_MOVE);
#endif
m_bAutoAttack = FALSE;
g_pPlayer->ClearCmd();
if( !bSpace )
m_objidTracking = NULL_ID;
}
if( m_objidTracking != NULL_ID )
{
CMover* pObjTracking = prj.GetMover( m_objidTracking );
if( pObjTracking )
{
D3DXVECTOR3 vDis = pMover->GetPos() - pObjTracking->GetPos();
if( D3DXVec3LengthSq( &vDis ) > 16 )
pMover->SetDestObj( m_objidTracking );
}
else
m_objidTracking = NULL_ID;
}
bool fMoved = false;
bool fBehavior = false;
if( bUp ) {
if( pMover->SendActMsg( OBJMSG_FORWARD ) == 1 ) {
fMoved = true;
fCastCancel = true;
}
}
else if( bDown ) {
if( pMover->SendActMsg( OBJMSG_BACKWARD ) == 1 ) {
fMoved = true;
fCastCancel = true;
}
}
#ifdef __Y_INTERFACE_VER3
else
if( bLForward ) {
if( pMover->SendActMsg( OBJMSG_LFORWARD ) == 1 ) {
fMoved = true;
fCastCancel = true;
}
}
else if( bRForward ) {
if( pMover->SendActMsg( OBJMSG_RFORWARD ) == 1 ) {
fMoved = true;
fCastCancel = true;
}
}
#endif //__Y_INTERFACE_VER3
else
// if( (bUp == FALSE && s_bUped == TRUE) || (bDown == FALSE && s_bDowned == TRUE) ) // 키를 뗀 순간에만 처리해보자..
if( bUp == FALSE || bDown == FALSE )
{
if( pMover->IsEmptyDest() )
{
if( pMover->m_pActMover->IsActJump() == FALSE && (pMover->m_pActMover->IsStateFlag( OBJSTAF_SIT ) ) == 0 ) // 앉아있을땐 실행하면 안된다.
{
if( pMover->SendActMsg( OBJMSG_STAND ) == 1 )
{
fMoved = true;
// TRACE( "PlayerMoved, " );
}
}
}
}
// s_bUped = bUp;
// s_bDowned = bDown;
if( bLeft ) {
if( pMover->SendActMsg( OBJMSG_LTURN ) == 1 ) {
fMoved = true;
}
}
else if( bRight ) {
if( pMover->SendActMsg( OBJMSG_RTURN ) == 1 ) {
fMoved = true;
}
}
else {
if( pMover->SendActMsg( OBJMSG_STOP_TURN ) == 1 ) {
fMoved = true;
// fBehavior = true;
}
}
// jump
if( bSpace )
{
#if __VER < 12 // __MOD_TUTORIAL
if( m_pWndGuideSystem )
m_pWndGuideSystem->SendGuideMessage(GUIDE_EVENT_KEY_JUMP);
#endif
if( pMover->SendActMsg( OBJMSG_JUMP ) == 1 )
{
fBehavior = true;
fCastCancel = true;
}
}
if( m_bLButtonDown == TRUE && m_bRButtonDown == TRUE ) {
if( m_timerLButtonDown.GetLeftTime() < 500 && m_timerRButtonDown.GetLeftTime() < 500 ) {
if( g_pPlayer->SendActMsg( OBJMSG_JUMP ) == 1 ) {
fBehavior = true;
fCastCancel = true;
}
}
}
#ifdef __Y_INTERFACE_VER3
if( g_Option.m_nInterface == 2 )
{
if( g_bKeyTable[VK_DIVIDE] || g_bKeyTable[191] )
{
bWalk = TRUE;
}
else
{
bWalk = FALSE;
}
}
else
{
bWalk = g_bKeyTable[g_Neuz.Key.chWalk];
}
#else //__Y_INTERFACE_VER3
bWalk = g_bKeyTable[g_Neuz.Key.chWalk];
#endif //__Y_INTERFACE_VER3
if( bWalk && !s_bWalk2 ) // 걷기 모드 토글.
{
if( pMover->m_pActMover->IsStateFlag( OBJSTAF_WALK ) )
{
if( pMover->SendActMsg( OBJMSG_MODE_RUN ) == 1 ) {
g_WndMng.PutString( prj.GetText( TID_GAME_RUN ), NULL, prj.GetTextColor( TID_GAME_RUN ) , CHATSTY_SYSTEM_CLIENT );
fBehavior = true;
}
} else
{
#if __VER < 12 // __MOD_TUTORIAL
if(m_pWndGuideSystem)
m_pWndGuideSystem->SendGuideMessage(GUIDE_EVENT_KEY_RUN);
#endif
if( pMover->SendActMsg( OBJMSG_MODE_WALK ) == 1 ) {
g_WndMng.PutString( prj.GetText( TID_GAME_WALK ), NULL, prj.GetTextColor( TID_GAME_WALK ) , CHATSTY_SYSTEM_CLIENT );
fBehavior = true;
}
}
}
s_bWalk2 = bWalk;
if( fMoved || fBehavior )
{
g_pPlayer->ClearDest();
#ifdef __J0823
g_DPlay.ClearPlayerDestPos();
#endif // __J0823
}
if( fMoved )
g_DPlay.SendPlayerMoved();
if( fBehavior )
g_DPlay.SendPlayerBehavior();
if( g_pPlayer->IsStateMode( STATE_BASEMOTION_MODE ) && fCastCancel ) // 캐스트 취소
{
g_DPlay.SendStateModeCancel( STATE_BASEMOTION_MODE, STATEMODE_BASEMOTION_CANCEL );
}
// 운영자가 쓰는 키. 서버로부터 좌표받아오기.
if( bTempKey = g_bKeyTable[ '8' ] )
{
if( !m_bTemp3ed )
{
pMover->SendActMsg( OBJMSG_TEMP2 );
// __bTestLOD ^= 1;
}
}
m_bTemp3ed = bTempKey;
//----------- 스킬사용.
/*
static BOOL s_bShift2, s_bKeyC2;
BOOL bShift, bKeyC;
if( g_Option.m_nInterface == 1 ) // 신버전 인터페이스 방식은 X 가 스킬사용이다.
{
bShift = g_bKeyTable[ VK_SHIFT ];
bKeyC = g_bKeyTable[ 'C' ];
if( bKeyC )
{
int a = 0;
}
if( (bShift && !s_bShift2) || (bKeyC && !s_bKeyC2) )
{
CObj* pTargetObj = CObj::m_pObjHighlight; // 커서를 대고 있던 오브젝트가 하이라이트 오브젝이다.
if( pTargetObj ) // 커서를 대고 있던 오브젝트가 있으면
{
pWorld->SetObjFocus( pTargetObj ); // 그놈을 셀렉트 하는 동시에.
CMover* pMover = (CMover*)pTargetObj;
if( pMover->GetType() == OT_MOVER )
m_dwNextSkill = NEXTSKILL_ACTIONSLOT; // 스킬 사용 예약.
} else
m_dwNextSkill = NEXTSKILL_ACTIONSLOT; // 스킬 사용 예약.
}
s_bShift2 = bShift;
s_bKeyC2 = bKeyC;
}
*/
//------------ 비공정 타기
if( bBoard )
{
if( !s_bBoarded ) // 플레이어가 비공정에 올라타있는 상태에서. 탑승키를 누르면.
{
if( g_pShip == NULL )
{
if( g_pPlayer->GetIAObjLink() && g_pPlayer->GetIAObjLink()->GetType() == OT_SHIP && g_pPlayer->GetIAObjLink()->GetIndex() == 3 )
{
CShip *pShip = (CShip *)g_pPlayer->GetIAObjLink();
if( pShip->GetMover() == NULL ) // 쥔장이 없는 배일때.
{
pShip->SetMover( g_pPlayer ); // 쥔장을 g_pPlayer로 설정.
g_pShip = pShip;
}
}
} else
// 이미 배를 조종하고 있을때
{
g_pShip->SetMover( NULL );
g_pShip = NULL;
}
}
}
s_bBoarded = bBoard;
#ifdef _DEBUG
// 디버깅용 키
if( bTempKey = g_bKeyTable[ VK_F2 ] )
{
if( !s_bTempKeyed )
{
// pMover->SendActMsg( OBJMSG_TEMP );
// g_Option.m_nObjectDetail ++;
// if( g_Option.m_nObjectDetail > 2 ) g_Option.m_nObjectDetail = 0;
}
}
s_bTempKeyed = bTempKey;
if( bTempKey = g_bKeyTable[ 'F' ] )
{
if( !m_bTemp2ed )
{
pMover->SendActMsg( OBJMSG_TEMP3 );
}
}
m_bTemp2ed = bTempKey;
#endif
return nMsg;
}
void CBackCamera::Process( LPDIRECT3DDEVICE9 pd3dDevice ,float fFactor )
{
#ifdef __CLIENT
CMover *pMover = CMover::GetActiveMover();
// 여기서 카메라 세팅!!!!!
if( pMover == NULL ) return;
CWorld* pWorld = pMover->GetWorld();
if( pWorld == NULL )
return;
D3DXMATRIX matView, mat;
FLOAT fAngle = 0, fAngleY = 0;
D3DXVECTOR3 vPos = pMover->GetPos();
vPos.y += 0.9f;
#if __VER >= 13 // __HOUSING
if(m_nCamMode == CM_MYROOM)
{
if(m_fZoom <= 0.5f) m_fZoom = 0.5f;
// if(m_fZoom >= 3.0f) m_fZoom = 3.0f;
}
#endif // __HOUSING
CMover* pMoverTarget = (CMover*)g_WorldMng.Get()->GetObjFocus() ;
D3DXVECTOR3 vTarget,vTemp;
if( pMoverTarget && pMover->m_pActMover->IsFly() && (pMover->m_dwFlag & MVRF_TRACKING) )
{ // 날고 있는 경우 타겟이 있다면
// 타겟쪽으로 카메라 방향을 수정한다.
vTemp = vPos - pMoverTarget->GetPos();
if( vTemp.z > 0 )
{
fAngle =- (float)( atan( vTemp.x / vTemp.z ) * 180 / 3.1415926f );
}
else
{
fAngle =- (float)( atan( vTemp.x / vTemp.z ) * 180 / 3.1415926f ) + 180;
}
D3DXVECTOR3 vDistXZ = vTemp;
vDistXZ.y = 0;
float fDistSq = D3DXVec3Length( &vDistXZ ); // XZ평면에서의 길이
fAngleY = atan2( fDistSq, vTemp.y/* * vTemp.y*/ );
fAngleY = D3DXToDegree( fAngleY );
float fReg1 = vTemp.y / 40.0f;
if( fReg1 > 0 )
{
if( fReg1 >= 2.0f ) fReg1 = 2.0f;
} else
if( fReg1 < 0 )
{
if( fReg1 <= -2.0f ) fReg1 = -2.0f;
}
m_fCurRoty = m_fRoty + m_fZoom * fReg1;
if( m_bLock )
fAngle = 0;
}
else
{
fAngle = pMover->GetAngle();
if( m_bLock )
fAngle = 0;
fAngleY = 90.0f;
m_fCurRoty = m_fRoty + m_fZoom * 4;
}
m_vLookAt = vPos;
#ifdef __Y_CAMERA_SLOW_8
if( !g_WndMng.m_pWndWorld->m_bRButtonDown && ( !g_bKeyTable[ VK_LEFT ] && !g_bKeyTable[ VK_RIGHT ] ) )
{
static FLOAT fSpeed = 2.0f;
BOOL bLeft = FALSE;
BOOL bRight = FALSE;
FLOAT fTemp = 0.0f;
fTemp = m_fRotx;
if( (GetAnglePie(fTemp) == 1 && GetAnglePie(m_fCurRotx) == 4) )
bRight = TRUE;
if( (GetAnglePie(fTemp) == 4 && GetAnglePie(m_fCurRotx) == 1) )
bLeft = TRUE;
if( bRight )
{
m_fCurRotx += m_fRotx;
if( m_fCurRotx < fTemp )
{
m_fCurRotx += fSpeed;
}
m_fCurRotx -= m_fRotx;
if( m_fCurRotx >= 0.0f )
{
m_fCurRotx = -360.0f;
}
}
if( bLeft )
{
fTemp += -360.0f;
if( m_fCurRotx > fTemp )
{
m_fCurRotx += -fSpeed;
if( m_fCurRotx < -360.0f )
m_fCurRotx = 0.0f;
}
fTemp -= -360.0f;
}
if( !bLeft && !bRight )
{
FLOAT fGoal = fabs(m_fCurRotx - fTemp);
if( m_fCurRotx < fTemp )
{
if( fGoal > fSpeed )
m_fCurRotx += fSpeed;
}
else
{
if( fGoal > fSpeed )
m_fCurRotx -= fSpeed;
}
}
}
else
{
m_fCurRotx = m_fRotx;
}
#else //__Y_CAMERA_SLOW_8
m_fCurRotx = m_fRotx;
#endif //__Y_CAMERA_SLOW_8
#ifdef __XUZHU
_g_fReg[0] = fAngleY;
#endif
float fAdjAng = (1.0f - fAngleY / 90.0f) * 45.0f;
m_fCurRoty += fAdjAng;
m_fCurRoty += pMover->GetAngleX();
if( pMover->m_pActMover->IsFly() ) // 비행할땐 조금 들어주자
m_fCurRoty += 0.0f;
if( m_fCurRoty > 80.0f )
m_fCurRoty = 80.0f;
#if __VER >= 13 // __HOUSING
if(m_nCamMode == CM_MYROOM)
{
if(m_fCurRoty <= 10.0f)
{
m_fCurRoty = 10.0f;
if(m_fRoty > 0.0f) m_fRoty = 0.0f;
if(m_fRoty < -30.0f) m_fRoty = -30.0f;
}
}
#endif // __HOUSING
fAngle = m_fCurRotx - fAngle + 180.0f;
D3DXMATRIX matTemp;
// zoom 상태에 따라 카메라 위치를 조정
extern float fDiv;
if( fDiv == 2.0f )
//vTemp = D3DXVECTOR3( 0.0f, 0.0f, -0.0f - (m_fZoom / 2.0f) * 2.0f );
vTemp = D3DXVECTOR3( 0.0f, 0.0f, -0.0f - 2.0f );
else
{
if( g_pShip )
vTemp = D3DXVECTOR3( 0.0f, 0.0f, -4.0f - m_fZoom * 16.0f );
else
//vTemp = D3DXVECTOR3( 0.0f, 0.0f, -50.0f );
vTemp = D3DXVECTOR3( 0.0f, 0.0f, -4.0f - m_fZoom * 2.0f );
}
D3DXVECTOR3 vecOut;
D3DXMatrixRotationX( &matTemp, D3DXToRadian( m_fCurRoty / 1.0f ) );
D3DXVec3TransformCoord( &vTemp, &vTemp, &matTemp );
D3DXMatrixRotationY( &matTemp, D3DXToRadian( fAngle ) );
D3DXVec3TransformCoord( &m_vOffsetDest, &vTemp, &matTemp );
D3DXVECTOR3 vecOffsetDelta = ( ( m_vOffsetDest - m_vOffset ) + m_vPosVal ) / fFactor;
m_vOffset += vecOffsetDelta;
m_vPosVal /= 2;
m_vPos = vPos + m_vOffset;
BOOL bCrash;
FLOAT fLength;
static D3DXVECTOR3 m_vLimitPos;
D3DXVECTOR3 m_vOutPos = m_vPos;
m_vLookAt.y += 0.4f;
#if __VER >= 11 // __GUILD_COMBAT_1TO1
if( g_pPlayer && g_GuildCombat1to1Mng.IsPossibleMover( g_pPlayer ) )
bCrash = FALSE;
else
bCrash = pWorld->CheckBound( &m_vPos, &m_vLookAt, &m_vOutPos, &fLength );
#else //__GUILD_COMBAT_1TO1
bCrash = pWorld->CheckBound( &m_vPos, &m_vLookAt, &m_vOutPos, &fLength );
#endif //__GUILD_COMBAT_1TO1
// 충돌이있다면 마지막으로 충돌했던 거리를 저장
if( bCrash )
m_fLength2 = fLength;
// 전프레임에 충돌, 현재는 충돌이 아닐때...즉, 서서히 뒤로 가게하는 시점..
if( m_bOld && bCrash == FALSE )
{
m_fLength1 = fLength;
m_bStart = TRUE;
}
if( m_bStart )
{
D3DXVECTOR3 vCPos = vPos + m_vOffset;
D3DXVECTOR3 vDir = vCPos - m_vLookAt;
D3DXVec3Normalize(&vDir, &vDir);
#if __VER >= 12 // __CAM_FAST_RECOVER
m_fLength2 += 0.37f;
#else
m_fLength2 += 0.07f;
#endif
if( m_fLength2 > fLength )
m_bStart = FALSE;
m_vOutPos = m_vLookAt + (vDir * m_fLength2);
}
else
if( bCrash )
{/*
if( fLength < 5.0f )
{
D3DXVECTOR3 vCPos = vPos + m_vOffset;
D3DXVECTOR3 vDir = vCPos - m_vLookAt;
D3DXVec3Normalize(&vDir, &vDir);
FLOAT fff = m_vOutPos.y;
m_vOutPos = m_vLookAt + (vDir * 5.0f);
m_vOutPos.y = fff;
}
*/
}
m_bOld = bCrash;
g_ModelGlobal.SetCamera( m_vOutPos, m_vLookAt );
m_vPos = m_vOutPos;
#endif // CLIENT
}
void CActorInstance::__ProcessDataAttackSuccess(const NRaceData::TAttackData & c_rAttackData, CActorInstance & rVictim, const D3DXVECTOR3 & c_rv3Position, UINT uiSkill, BOOL isSendPacket)
{
if (NRaceData::HIT_TYPE_NONE == c_rAttackData.iHittingType)
return;
InsertDelay(c_rAttackData.fStiffenTime);
if (__CanPushDestActor(rVictim) && c_rAttackData.fExternalForce > 0.0f)
{
__PushCircle(rVictim);
// VICTIM_COLLISION_TEST
const D3DXVECTOR3& kVictimPos = rVictim.GetPosition();
rVictim.m_PhysicsObject.IncreaseExternalForce(kVictimPos, c_rAttackData.fExternalForce); //*nForceRatio/100.0f);
// VICTIM_COLLISION_TEST_END
}
// Invisible Time
if (IS_PARTY_HUNTING_RACE(rVictim.GetRace()))
{
if (uiSkill) // 파티 사냥 몬스터라도 스킬이면 무적시간 적용
rVictim.m_fInvisibleTime = CTimer::Instance().GetCurrentSecond() + c_rAttackData.fInvisibleTime;
if (m_isMain) // #0000794: [M2KR] 폴리모프 - 밸런싱 문제 타인 공격에 의한 무적 타임은 고려하지 않고 자신 공격에 의한것만 체크한다
rVictim.m_fInvisibleTime = CTimer::Instance().GetCurrentSecond() + c_rAttackData.fInvisibleTime;
}
else // 파티 사냥 몬스터가 아닐 경우만 적용
{
rVictim.m_fInvisibleTime = CTimer::Instance().GetCurrentSecond() + c_rAttackData.fInvisibleTime;
}
// Stiffen Time
rVictim.InsertDelay(c_rAttackData.fStiffenTime);
// Hit Effect
D3DXVECTOR3 vec3Effect(rVictim.m_x, rVictim.m_y, rVictim.m_z);
// #0000780: [M2KR] 수룡 타격구 문제
extern bool IS_HUGE_RACE(unsigned int vnum);
if (IS_HUGE_RACE(rVictim.GetRace()))
{
vec3Effect = c_rv3Position;
}
const D3DXVECTOR3 & v3Pos = GetPosition();
float fHeight = D3DXToDegree(atan2(-vec3Effect.x + v3Pos.x,+vec3Effect.y - v3Pos.y));
// 2004.08.03.myevan.빌딩이나 문의 경우 타격 효과가 보이지 않는다
if (rVictim.IsBuilding()||rVictim.IsDoor())
{
D3DXVECTOR3 vec3Delta=vec3Effect-v3Pos;
D3DXVec3Normalize(&vec3Delta, &vec3Delta);
vec3Delta*=30.0f;
CEffectManager& rkEftMgr=CEffectManager::Instance();
if (m_dwBattleHitEffectID)
rkEftMgr.CreateEffect(m_dwBattleHitEffectID, v3Pos+vec3Delta, D3DXVECTOR3(0.0f, 0.0f, 0.0f));
}
else
{
CEffectManager& rkEftMgr=CEffectManager::Instance();
if (m_dwBattleHitEffectID)
rkEftMgr.CreateEffect(m_dwBattleHitEffectID, vec3Effect, D3DXVECTOR3(0.0f, 0.0f, fHeight));
if (m_dwBattleAttachEffectID)
rVictim.AttachEffectByID(0, NULL, m_dwBattleAttachEffectID);
}
if (rVictim.IsBuilding())
{
// 2004.08.03.빌딩의 경우 흔들리면 이상하다
}
else if (rVictim.IsStone() || rVictim.IsDoor())
{
__HitStone(rVictim);
}
else
{
///////////
// Motion
if (NRaceData::HIT_TYPE_GOOD == c_rAttackData.iHittingType || rVictim.IsResistFallen())
{
__HitGood(rVictim);
}
else if (NRaceData::HIT_TYPE_GREAT == c_rAttackData.iHittingType)
{
__HitGreate(rVictim);
}
else
{
TraceError("ProcessSucceedingAttacking: Unknown AttackingData.iHittingType %d", c_rAttackData.iHittingType);
}
}
__OnHit(uiSkill, rVictim, isSendPacket);
}
