void CKinectProc::BatchAngel(double *data,double *outputData,int height,int width,int channel)
{
int lineWidth = channel * width;
for (int i = 0; i < height; ++i)
{
vector<double> meanVal(channel,0);
GetBodyCenter(data + i*lineWidth,width,channel,meanVal);
std::cout<<"BodyNo:"<<i<<". "<<" body center ok!"<<std::endl;
for (int j = 0; j < width; ++j)
{
vector<double> val(channel,0);
GetAngle(data + i*lineWidth + j * channel,&meanVal[0],channel,val);
for (int k = 0; k < channel; ++k)
{
outputData[i*lineWidth + j * channel + k] = val[k];
}
//val.clear();
}
std::cout<<"BodyNo:"<<i<<". "<<" Angle ok!"<<std::endl;
//meanVal.clear();
}
}
void Encoder::Load(physics::ModelPtr model, sdf::ElementPtr sdf) {
this->model = model;
// Parse SDF properties
joint = model->GetJoint(sdf->Get<std::string>("joint"));
if (sdf->HasElement("topic")) {
topic = sdf->Get<std::string>("topic");
} else {
topic = "~/" + sdf->GetAttribute("name")->GetAsString();
}
if (sdf->HasElement("units")) {
radians = sdf->Get<std::string>("units") != "degrees";
} else {
radians = true;
}
zero = GetAngle();
stopped = true;
stop_value = 0;
gzmsg << "Initializing encoder: " << topic << " joint=" << joint->GetName()
<< " radians=" << radians << std::endl;
// Connect to Gazebo transport for messaging
std::string scoped_name =
model->GetWorld()->GetName() + "::" + model->GetScopedName();
boost::replace_all(scoped_name, "::", "/");
node = transport::NodePtr(new transport::Node());
node->Init(scoped_name);
command_sub = node->Subscribe(topic + "/control", &Encoder::Callback, this);
pos_pub = node->Advertise<msgs::Float64>(topic + "/position");
vel_pub = node->Advertise<msgs::Float64>(topic + "/velocity");
// Connect to the world update event.
// This will trigger the Update function every Gazebo iteration
updateConn = event::Events::ConnectWorldUpdateBegin(
boost::bind(&Encoder::Update, this, _1));
}
void EDGE_MODULE::Mirror( wxPoint aCentre, bool aMirrorAroundXAxis )
{
// Mirror an edge of the footprint. the layer is not modified
// This is a footprint shape modification.
switch( GetShape() )
{
case S_ARC:
SetAngle( -GetAngle() );
//Fall through
default:
case S_SEGMENT:
if( aMirrorAroundXAxis )
{
MIRROR( m_Start0.y, aCentre.y );
MIRROR( m_End0.y, aCentre.y );
}
else
{
MIRROR( m_Start0.x, aCentre.x );
MIRROR( m_End0.x, aCentre.x );
}
break;
case S_POLYGON:
// polygon corners coordinates are always relative to the
// footprint position, orientation 0
for( unsigned ii = 0; ii < m_PolyPoints.size(); ii++ )
{
if( aMirrorAroundXAxis )
MIRROR( m_PolyPoints[ii].y, aCentre.y );
else
MIRROR( m_PolyPoints[ii].x, aCentre.x );
}
}
SetDrawCoord();
}
/**\brief Accelerates the ship.
* \sa Model::GetAcceleration
*/
void Ship::Accelerate( void ) {
Trig *trig = Trig::Instance();
Coordinate momentum = GetMomentum();
float angle = static_cast<float>(trig->DegToRad( GetAngle() ));
float speed = shipStats.GetMaxSpeed()*engineBooster;
float acceleration = (shipStats.GetForceOutput() *engineBooster ) / shipStats.GetMass();
momentum += Coordinate( trig->GetCos( angle ) * acceleration * Timer::GetDelta(),
-1 * trig->GetSin( angle ) * acceleration * Timer::GetDelta() );
momentum.EnforceMagnitude(speed);
SetMomentum( momentum );
status.isAccelerating = true;
// Play engine sound
float engvol = OPTION(float,"options/sound/engines");
Coordinate offset = GetWorldPosition() - Camera::Instance()->GetFocusCoordinate();
if ( this->GetDrawOrder() == DRAW_ORDER_SHIP )
engvol = engvol * NON_PLAYER_SOUND_RATIO ;
this->engine->GetSound()->SetVolume( engvol );
this->engine->GetSound()->PlayNoRestart( offset );
}
void EDGE_MODULE::Flip(const wxPoint& aCentre )
{
wxPoint pt;
switch( GetShape() )
{
case S_ARC:
SetAngle( -GetAngle() );
//Fall through
default:
case S_SEGMENT:
pt = GetStart();
pt.y -= aCentre.y;
pt.y = -pt.y;
pt.y += aCentre.y;
SetStart( pt );
pt = GetEnd();
pt.y -= aCentre.y;
pt.y = -pt.y;
pt.y += aCentre.y;
SetEnd( pt );
NEGATE( m_Start0.y );
NEGATE( m_End0.y );
break;
case S_POLYGON:
// polygon corners coordinates are always relative to the
// footprint position, orientation 0
for( unsigned ii = 0; ii < m_PolyPoints.size(); ii++ )
NEGATE( m_PolyPoints[ii].y );
}
SetLayer( FlipLayer( GetLayer() ) );
}
void EDGE_MODULE::Flip( const wxPoint& aCentre )
{
wxPoint pt;
switch( GetShape() )
{
case S_ARC:
SetAngle( -GetAngle() );
//Fall through
default:
case S_SEGMENT:
pt = GetStart();
MIRROR( pt.y, aCentre.y );
SetStart( pt );
pt = GetEnd();
MIRROR( pt.y, aCentre.y );
SetEnd( pt );
MIRROR( m_Start0.y, 0 );
MIRROR( m_End0.y, 0 );
break;
case S_POLYGON:
// polygon corners coordinates are always relative to the
// footprint position, orientation 0
for( unsigned ii = 0; ii < m_PolyPoints.size(); ii++ )
MIRROR( m_PolyPoints[ii].y, 0 );
}
// DRAWSEGMENT items are not usually on copper layers, but
// it can happen in microwave apps.
// However, currently, only on Front or Back layers.
// So the copper layers count is not taken in account
SetLayer( FlipLayer( GetLayer() ) );
}
std::string
Simbox::getStormHeader(int cubetype, int nx, int ny, int nz, bool flat, bool ascii) const
{
if(flat == false)
assert(topName_ != "");
std::string header;
if(ascii == false)
header = "storm_petro_binary\n";
else
header = "storm_petro_ascii\n";
header += "0 "+NRLib::ToString(cubetype) +" "+ NRLib::ToString(RMISSING,6)+"\n";
header += "FFTGrid\n";
if(flat == false)
header += NRLib::ToString(GetXMin(),6) +" "+ NRLib::ToString(GetLX(),6) +" "+ NRLib::ToString(GetYMin(),6) +" "+ NRLib::ToString(GetLY(),6) +" "+ topName_ +" "+ botName_ +" 0.0 0.0\n";
else
header += NRLib::ToString(GetXMin(),6) +" "+ NRLib::ToString(GetLX(),6) +" "+ NRLib::ToString(GetYMin(),6) +" "+ NRLib::ToString(GetLY(),6) +" 0.0 "+ NRLib::ToString(GetLZ(),6)+" 0.0 0.0\n";
header += NRLib::ToString(GetLZ(),6) +" "+ NRLib::ToString(GetAngle()*180/NRLib::Pi,6)+"\n\n";
header += NRLib::ToString(nx) +" "+ NRLib::ToString(ny) +" "+ NRLib::ToString(nz)+"\n";
std::string strHeader(header);
return(strHeader);
}
void ribi::QtPathArrowItem::paint(QPainter *painter, const QStyleOptionGraphicsItem *, QWidget *)
{
painter->setRenderHint(QPainter::Antialiasing);
if (this->isSelected() || this->hasFocus())
{
painter->setPen(m_focus_pen);
}
else
{
painter->setPen(m_pen);
}
{
//Draw the lines
painter->drawLine(m_tail_pos,m_mid_pos[0]);
const std::size_t max = m_mid_pos.size() - 1; //-1, because the line goes to the next index
for (std::size_t i = 0; i!= max; ++i)
{
painter->drawLine(m_mid_pos[i],m_mid_pos[i+1]);
}
painter->drawLine(m_mid_pos[ m_mid_pos.size() - 1 ],m_head_pos);
}
const double sz = 10.0; //pixels
if (m_tail)
{
const double pi = boost::math::constants::pi<double>();
const double dx = m_mid_pos[0].x() - m_tail_pos.x();
const double dy = m_mid_pos[0].y() - m_tail_pos.y();
double angle = GetAngle(dx,dy);
if (dy >= 0.0) angle = (1.0 * pi) + angle;
//const QPointF m_tail_pos(m_tail_x,m_tail_y);
const QPointF p1
= m_tail_pos + QPointF(
std::sin(angle + pi + (pi * 0.1)) * sz,
-std::cos(angle + pi + (pi * 0.1)) * sz);
const QPointF p2
= m_tail_pos + QPointF(
std::sin(angle + pi - (pi * 0.1)) * sz,
-std::cos(angle + pi - (pi * 0.1)) * sz);
painter->drawPolygon(QPolygonF() << m_tail_pos << p1 << p2);
}
if (m_head)
{
const double pi = boost::math::constants::pi<double>();
const double dx = m_head_pos.x() - m_mid_pos[m_mid_pos.size() - 1].x();
const double dy = m_head_pos.y() - m_mid_pos[m_mid_pos.size() - 1].y();
double angle = GetAngle(dx,dy);
if (dy >= 0.0) angle = (1.0 * pi) + angle;
const QPointF p1
= m_head_pos + QPointF(
std::sin(angle + 0.0 + (pi * 0.1)) * sz,
-std::cos(angle + 0.0 + (pi * 0.1)) * sz);
const QPointF p2
= m_head_pos + QPointF(
std::sin(angle + 0.0 - (pi * 0.1)) * sz,
-std::cos(angle + 0.0 - (pi * 0.1)) * sz);
painter->drawPolygon(QPolygonF() << m_head_pos << p1 << p2);
}
}
int WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance,
LPSTR lpCmdLine, int nCmdShow)
{
WNDCLASSEX window_class = {};
window_class.cbSize = sizeof(window_class);
window_class.style = CS_HREDRAW | CS_VREDRAW;
window_class.lpfnWndProc = WindowCallback;
window_class.hInstance = hInstance;
window_class.hCursor = LoadCursor(NULL, IDC_ARROW);
window_class.lpszClassName = "WCPetroCanada";
RegisterClassEx(&window_class);
HWND window = CreateWindowEx(WS_EX_OVERLAPPEDWINDOW, "WCPetroCanada", "Game :)", WS_OVERLAPPEDWINDOW,
CW_USEDEFAULT, CW_USEDEFAULT,
1280, 720,
NULL, NULL, hInstance, NULL);
ShowWindow(window, nCmdShow);
UpdateWindow(window);
RECT client_rect = {};
GetClientRect(window, &client_rect);
Framebuffer backbuffer = {};
backbuffer.width = client_rect.right;
backbuffer.height = client_rect.bottom;
backbuffer.pixels = (uint32_t *)VirtualAlloc(NULL, backbuffer.width * backbuffer.height * sizeof(uint32_t ), MEM_RESERVE | MEM_COMMIT, PAGE_READWRITE);
HDC window_context = GetDC(window);
BITMAPINFO bitmap_info = {};
bitmap_info.bmiHeader.biSize = sizeof(bitmap_info);
bitmap_info.bmiHeader.biWidth = backbuffer.width;
bitmap_info.bmiHeader.biHeight = backbuffer.height;
bitmap_info.bmiHeader.biPlanes = 1;
bitmap_info.bmiHeader.biBitCount = 32;
bitmap_info.bmiHeader.biCompression = BI_RGB;
LoadedBitmap player_head = LoadBitmap("petro.bmp");
MSG message;
bool open = true;
Vector2 velocity = V2(0, 0);
Vector2 position = V2(200, 200);
float timestep = 1.0f; //TODO proper timestep
EntityArray entities = {};
Entity *player_entity = MakeEntity(&entities, EntityType_Player, V2(200, 200), player_head.width, player_head.height, V2(10, 10));
MakeEntity(&entities, EntityType_Box, V2(50, 50), 100, 100);
bool w_down = false;
bool a_down = false;
bool s_down = false;
bool d_down = false;
bool q_down = false;
while(open)
{
while(PeekMessage(&message, NULL, 0,
0, PM_REMOVE))
{
if(message.message == WM_QUIT)
{
open = false;
}
else if(message.message == WM_KEYDOWN)
{
if(message.wParam == W_KEY_CODE)
{
w_down = true;
}
else if(message.wParam == S_KEY_CODE)
{
s_down = true;
}
else if(message.wParam == D_KEY_CODE)
{
d_down = true;
}
else if(message.wParam == A_KEY_CODE)
{
a_down = true;
}
else if(message.wParam == Q_KEY_CODE)
{
q_down = true;
}
}
else if(message.message == WM_KEYUP)
{
if(message.wParam == W_KEY_CODE)
{
w_down = false;
}
else if(message.wParam == S_KEY_CODE)
{
s_down = false;
}
else if(message.wParam == D_KEY_CODE)
{
d_down = false;
}
else if(message.wParam == A_KEY_CODE)
{
a_down = false;
}
else if(message.wParam == Q_KEY_CODE)
{
q_down = false;
}
}
TranslateMessage(&message);
DispatchMessage(&message);
}
DrawRectangle(0, 0, backbuffer.width, backbuffer.height, backbuffer, V4(0.0f, 0.0f, 0.0f, 1.0f));
DrawRectangle(100, 100, 100, 100, backbuffer, V4(position.x / (float)backbuffer.width, position.y / (float)backbuffer.height, 0.0f, 1.0f));
DrawRectangle(100, 100, 150, 150, backbuffer, V4(0.0f, 1.0f, 0.0f, 0.25f));
for(int i = 0; i < entities.count; i++)
{
Entity *entity = entities.entities + i;
if(entity->type != EntityType_Invalid)
{
Vector2 acceleration = V2(0, 0);
if(entity == player_entity)
{
float multiplier = 1.0f;
if(w_down)
{
acceleration = acceleration + V2(0, 1);
}
if(s_down)
{
acceleration = acceleration + V2(0, -1);
}
if(d_down)
{
acceleration = acceleration + V2(1, 0);
}
if(a_down)
{
acceleration = acceleration + V2(-1, 0);
}
if(q_down)
{
multiplier = 5.0f;
}
if(Length(acceleration) > 0)
{
acceleration = Normalize(acceleration) * multiplier;
}
}
acceleration = acceleration - (entity->velocity * 0.05f);
Vector2 new_velocity = (acceleration * timestep) + entity->velocity;
Vector2 new_position = (acceleration * 0.5f * timestep * timestep) + (new_velocity * timestep) + GetCenter(entity->bounds);
Rect2 collision_box = RectPosSize(new_position.x, new_position.y, GetWidth(entity->bounds), GetHeight(entity->bounds));
bool intersects = false;
for(int j = 0; j < entities.count; j++)
{
if(j != i)
{
Entity *other_entity = entities.entities + j;
intersects = intersects || Intersect(other_entity->bounds, collision_box);
}
}
if(!intersects)
{
entity->velocity = new_velocity;
entity->bounds = RectPosSize(new_position.x, new_position.y, GetWidth(entity->bounds), GetHeight(entity->bounds));
}
else
{
entity->velocity = V2(0, 0);
}
switch(entity->type)
{
case EntityType_Box:
{
DrawRectangle(entity->bounds.min.x, entity->bounds.min.y,
GetWidth(entity->bounds), GetHeight(entity->bounds),
backbuffer, V4(1.0f, 0.0f, 0.0f, 1.0f));
}
break;
case EntityType_Player:
{
float angle = GetAngle(entity->velocity);
Direction direction = AngleToDirection(angle);
Vector4 color = V4(1.0f, 1.0f, 1.0f, 0.0f);
if(direction == Direction_Up)
{
color = V4(1.0f, 0.0f, 0.0f, 1.0f);
}
else if(direction == Direction_Down)
{
color = V4(1.0f, 1.0f, 0.0f, 1.0f);
}
else if(direction == Direction_Left)
{
color = V4(0.0f, 1.0f, 1.0f, 1.0f);
}
else if(direction == Direction_Right)
{
color = V4(0.0f, 1.0f, 0.0f, 1.0f);
}
char output[255];
sprintf(output, "%f\n", angle);
OutputDebugStringA(output);
DrawRectangle(300,
300,
10, 10,
backbuffer, color);
DrawRectangle(entity->bounds.min.x,
entity->bounds.min.y,
GetWidth(entity->bounds), GetHeight(entity->bounds),
backbuffer, intersects ? V4(0.5f, 0.0f, 0.0f, 0.5f) : V4(0.5f, 0.5f, 0.5f, 0.5f));
DrawBitmap(entity->bounds.min.x,
entity->bounds.min.y,
GetWidth(entity->bounds), GetHeight(entity->bounds),
backbuffer, player_head);
}
break;
}
}
}
StretchDIBits(window_context,
0, 0, backbuffer.width, backbuffer.height,
0, 0, backbuffer.width, backbuffer.height,
backbuffer.pixels, &bitmap_info, DIB_RGB_COLORS, SRCCOPY);
}
return 0;
}
bool Shooter::IsAtAngle(){
bool ontarget=angle_pid->OnTarget();
GetAngle();
return ontarget;
}
/**
*@brief ÒÑ֪бÂÊ»ñµÃœÇ¶È
*@param rake [in] бÂÊ
*@return œÇ¶ÈÊý
*/
float CalHOT::GetRakeAngle(float rake)
{
return GetAngle(GetRakeRadian(rake));
}
void CPlayers::RenderPlayer(
const CNetObj_Character *pPrevChar,
const CNetObj_Character *pPlayerChar,
const CNetObj_PlayerInfo *pPrevInfo,
const CNetObj_PlayerInfo *pPlayerInfo
)
{
CNetObj_Character Prev;
CNetObj_Character Player;
Prev = *pPrevChar;
Player = *pPlayerChar;
CNetObj_PlayerInfo pInfo = *pPlayerInfo;
CTeeRenderInfo RenderInfo = m_pClient->m_aClients[pInfo.m_ClientId].m_RenderInfo;
// check for teamplay modes
bool IsTeamplay = false;
bool NewTick = m_pClient->m_NewTick;
if(m_pClient->m_Snap.m_pGameobj)
IsTeamplay = (m_pClient->m_Snap.m_pGameobj->m_Flags&GAMEFLAG_TEAMS) != 0;
// check for ninja
if (Player.m_Weapon == WEAPON_NINJA)
{
// change the skin for the player to the ninja
int Skin = m_pClient->m_pSkins->Find("x_ninja");
if(Skin != -1)
{
if(IsTeamplay)
RenderInfo.m_Texture = m_pClient->m_pSkins->Get(Skin)->m_ColorTexture;
else
{
RenderInfo.m_Texture = m_pClient->m_pSkins->Get(Skin)->m_OrgTexture;
RenderInfo.m_ColorBody = vec4(1,1,1,1);
RenderInfo.m_ColorFeet = vec4(1,1,1,1);
}
}
}
// set size
RenderInfo.m_Size = 64.0f;
float IntraTick = Client()->IntraGameTick();
if(Player.m_Health < 0) // dont render dead players
return;
float Angle = mix((float)Prev.m_Angle, (float)Player.m_Angle, IntraTick)/256.0f;
//float angle = 0;
if(pInfo.m_Local && Client()->State() != IClient::STATE_DEMOPLAYBACK)
{
// just use the direct input if it's local player we are rendering
Angle = GetAngle(m_pClient->m_pControls->m_MousePos);
}
else
{
/*
float mixspeed = Client()->FrameTime()*2.5f;
if(player.attacktick != prev.attacktick) // shooting boosts the mixing speed
mixspeed *= 15.0f;
// move the delta on a constant speed on a x^2 curve
float current = g_GameClient.m_aClients[info.cid].angle;
float target = player.angle/256.0f;
float delta = angular_distance(current, target);
float sign = delta < 0 ? -1 : 1;
float new_delta = delta - 2*mixspeed*sqrt(delta*sign)*sign + mixspeed*mixspeed;
// make sure that it doesn't vibrate when it's still
if(fabs(delta) < 2/256.0f)
angle = target;
else
angle = angular_approach(current, target, fabs(delta-new_delta));
g_GameClient.m_aClients[info.cid].angle = angle;*/
}
// use preditect players if needed
if(pInfo.m_Local && g_Config.m_ClPredict && Client()->State() != IClient::STATE_DEMOPLAYBACK)
{
if(!m_pClient->m_Snap.m_pLocalCharacter || (m_pClient->m_Snap.m_pLocalCharacter->m_Health < 0) || (m_pClient->m_Snap.m_pGameobj && m_pClient->m_Snap.m_pGameobj->m_GameOver))
{
}
else
{
// apply predicted results
m_pClient->m_PredictedChar.Write(&Player);
m_pClient->m_PredictedPrevChar.Write(&Prev);
IntraTick = Client()->PredIntraGameTick();
NewTick = m_pClient->m_NewPredictedTick;
}
}
vec2 Direction = GetDirection((int)(Angle*256.0f));
vec2 Position = mix(vec2(Prev.m_X, Prev.m_Y), vec2(Player.m_X, Player.m_Y), IntraTick);
vec2 Vel = mix(vec2(Prev.m_VelX/256.0f, Prev.m_VelY/256.0f), vec2(Player.m_VelX/256.0f, Player.m_VelY/256.0f), IntraTick);
m_pClient->m_pFlow->Add(Position, Vel*100.0f, 10.0f);
RenderInfo.m_GotAirJump = Player.m_Jumped&2?0:1;
// detect events
if(NewTick)
{
// detect air jump
if(!RenderInfo.m_GotAirJump && !(Prev.m_Jumped&2))
m_pClient->m_pEffects->AirJump(Position);
}
if(Prev.m_Health < 0) // Don't flicker from previous position
Position = vec2(Player.m_X, Player.m_Y);
bool Stationary = Player.m_VelX <= 1 && Player.m_VelX >= -1;
bool InAir = !Collision()->CheckPoint(Player.m_X, Player.m_Y+16);
bool WantOtherDir = (Player.m_Direction == -1 && Vel.x > 0) || (Player.m_Direction == 1 && Vel.x < 0);
// evaluate animation
float WalkTime = fmod(absolute(Position.x), 100.0f)/100.0f;
CAnimState State;
State.Set(&g_pData->m_aAnimations[ANIM_BASE], 0);
if(InAir)
State.Add(&g_pData->m_aAnimations[ANIM_INAIR], 0, 1.0f); // TODO: some sort of time here
else if(Stationary)
State.Add(&g_pData->m_aAnimations[ANIM_IDLE], 0, 1.0f); // TODO: some sort of time here
else if(!WantOtherDir)
State.Add(&g_pData->m_aAnimations[ANIM_WALK], WalkTime, 1.0f);
if (Player.m_Weapon == WEAPON_HAMMER)
{
float ct = (Client()->PrevGameTick()-Player.m_AttackTick)/(float)SERVER_TICK_SPEED + Client()->GameTickTime();
State.Add(&g_pData->m_aAnimations[ANIM_HAMMER_SWING], clamp(ct*5.0f,0.0f,1.0f), 1.0f);
}
if (Player.m_Weapon == WEAPON_NINJA)
{
float ct = (Client()->PrevGameTick()-Player.m_AttackTick)/(float)SERVER_TICK_SPEED + Client()->GameTickTime();
State.Add(&g_pData->m_aAnimations[ANIM_NINJA_SWING], clamp(ct*2.0f,0.0f,1.0f), 1.0f);
}
// do skidding
if(!InAir && WantOtherDir && length(Vel*50) > 500.0f)
{
static int64 SkidSoundTime = 0;
if(time_get()-SkidSoundTime > time_freq()/10)
{
m_pClient->m_pSounds->Play(CSounds::CHN_WORLD, SOUND_PLAYER_SKID, 0.25f, Position);
SkidSoundTime = time_get();
}
m_pClient->m_pEffects->SkidTrail(
Position+vec2(-Player.m_Direction*6,12),
vec2(-Player.m_Direction*100*length(Vel),-50)
);
}
// draw gun
{
Graphics()->TextureSet(g_pData->m_aImages[IMAGE_GAME].m_Id);
Graphics()->QuadsBegin();
Graphics()->QuadsSetRotation(State.GetAttach()->m_Angle*pi*2+Angle);
// normal weapons
int iw = clamp(Player.m_Weapon, 0, NUM_WEAPONS-1);
RenderTools()->SelectSprite(g_pData->m_Weapons.m_aId[iw].m_pSpriteBody, Direction.x < 0 ? SPRITE_FLAG_FLIP_Y : 0);
vec2 Dir = Direction;
float Recoil = 0.0f;
vec2 p;
if (Player.m_Weapon == WEAPON_HAMMER)
{
// Static position for hammer
p = Position + vec2(State.GetAttach()->m_X, State.GetAttach()->m_Y);
p.y += g_pData->m_Weapons.m_aId[iw].m_Offsety;
// if attack is under way, bash stuffs
if(Direction.x < 0)
{
Graphics()->QuadsSetRotation(-pi/2-State.GetAttach()->m_Angle*pi*2);
p.x -= g_pData->m_Weapons.m_aId[iw].m_Offsetx;
}
else
{
Graphics()->QuadsSetRotation(-pi/2+State.GetAttach()->m_Angle*pi*2);
}
RenderTools()->DrawSprite(p.x, p.y, g_pData->m_Weapons.m_aId[iw].m_VisualSize);
}
else if (Player.m_Weapon == WEAPON_NINJA)
{
p = Position;
p.y += g_pData->m_Weapons.m_aId[iw].m_Offsety;
if(Direction.x < 0)
{
Graphics()->QuadsSetRotation(-pi/2-State.GetAttach()->m_Angle*pi*2);
p.x -= g_pData->m_Weapons.m_aId[iw].m_Offsetx;
m_pClient->m_pEffects->PowerupShine(p+vec2(32,0), vec2(32,12));
}
else
{
Graphics()->QuadsSetRotation(-pi/2+State.GetAttach()->m_Angle*pi*2);
m_pClient->m_pEffects->PowerupShine(p-vec2(32,0), vec2(32,12));
}
RenderTools()->DrawSprite(p.x, p.y, g_pData->m_Weapons.m_aId[iw].m_VisualSize);
// HADOKEN
if ((Client()->GameTick()-Player.m_AttackTick) <= (SERVER_TICK_SPEED / 6) && g_pData->m_Weapons.m_aId[iw].m_NumSpriteMuzzles)
{
int IteX = rand() % g_pData->m_Weapons.m_aId[iw].m_NumSpriteMuzzles;
float Alpha = 1.0f;
if (Alpha > 0.0f && g_pData->m_Weapons.m_aId[iw].m_aSpriteMuzzles[IteX])
{
vec2 Dir = vec2(pPlayerChar->m_X,pPlayerChar->m_Y) - vec2(pPrevChar->m_X, pPrevChar->m_Y);
Dir = normalize(Dir);
float HadOkenAngle = GetAngle(Dir);
Graphics()->QuadsSetRotation(HadOkenAngle );
//float offsety = -data->weapons[iw].muzzleoffsety;
RenderTools()->SelectSprite(g_pData->m_Weapons.m_aId[iw].m_aSpriteMuzzles[IteX], 0);
vec2 DirY(-Dir.y,Dir.x);
p = Position;
float OffsetX = g_pData->m_Weapons.m_aId[iw].m_Muzzleoffsetx;
p -= Dir * OffsetX;
RenderTools()->DrawSprite(p.x, p.y, 160.0f);
}
}
}
else
{
// TODO: should be an animation
Recoil = 0;
float a = (Client()->GameTick()-Player.m_AttackTick+IntraTick)/5.0f;
if(a < 1)
Recoil = sinf(a*pi);
p = Position + Dir * g_pData->m_Weapons.m_aId[iw].m_Offsetx - Dir*Recoil*10.0f;
p.y += g_pData->m_Weapons.m_aId[iw].m_Offsety;
RenderTools()->DrawSprite(p.x, p.y, g_pData->m_Weapons.m_aId[iw].m_VisualSize);
}
if (Player.m_Weapon == WEAPON_GUN || Player.m_Weapon == WEAPON_SHOTGUN)
{
// check if we're firing stuff
if(g_pData->m_Weapons.m_aId[iw].m_NumSpriteMuzzles)//prev.attackticks)
{
float Alpha = 0.0f;
int Phase1Tick = (Client()->GameTick() - Player.m_AttackTick);
if (Phase1Tick < (g_pData->m_Weapons.m_aId[iw].m_Muzzleduration + 3))
{
float t = ((((float)Phase1Tick) + IntraTick)/(float)g_pData->m_Weapons.m_aId[iw].m_Muzzleduration);
Alpha = mix(2.0f, 0.0f, min(1.0f,max(0.0f,t)));
}
int IteX = rand() % g_pData->m_Weapons.m_aId[iw].m_NumSpriteMuzzles;
if (Alpha > 0.0f && g_pData->m_Weapons.m_aId[iw].m_aSpriteMuzzles[IteX])
{
float OffsetY = -g_pData->m_Weapons.m_aId[iw].m_Muzzleoffsety;
RenderTools()->SelectSprite(g_pData->m_Weapons.m_aId[iw].m_aSpriteMuzzles[IteX], Direction.x < 0 ? SPRITE_FLAG_FLIP_Y : 0);
if(Direction.x < 0)
OffsetY = -OffsetY;
vec2 DirY(-Dir.y,Dir.x);
vec2 MuzzlePos = p + Dir * g_pData->m_Weapons.m_aId[iw].m_Muzzleoffsetx + DirY * OffsetY;
RenderTools()->DrawSprite(MuzzlePos.x, MuzzlePos.y, g_pData->m_Weapons.m_aId[iw].m_VisualSize);
}
}
}
Graphics()->QuadsEnd();
switch (Player.m_Weapon)
{
case WEAPON_GUN: RenderHand(&RenderInfo, p, Direction, -3*pi/4, vec2(-15, 4)); break;
case WEAPON_SHOTGUN: RenderHand(&RenderInfo, p, Direction, -pi/2, vec2(-5, 4)); break;
case WEAPON_GRENADE: RenderHand(&RenderInfo, p, Direction, -pi/2, vec2(-4, 7)); break;
}
}
//--- Antiping
// Draw shadows of enemy tees
bool LocalPlayerInGame = m_pClient->m_aClients[m_pClient->m_Snap.m_LocalCid].m_Team != -1;
bool CurPlayerIsEnemy =
IsTeamplay == false ||
(IsTeamplay && m_pClient->m_aClients[m_pClient->m_Snap.m_LocalCid].m_Team != m_pClient->m_aClients[pPlayerInfo->m_ClientId].m_Team);
if (g_Config.m_AntiPing &&
g_Config.m_AntiPing != 2 && // if == 2, than we should show only grenage shadows
LocalPlayerInGame && pInfo.m_Local == false && CurPlayerIsEnemy &&
pPlayerChar && pPlayerChar->m_PlayerState == PLAYERSTATE_PLAYING)
{
CCharacterCore ShadowPlayer;
CNetObj_CharacterCore buf;
m_pClient->m_aClients[pPlayerInfo->m_ClientId].m_Predicted.Write(&buf);
CWorldCore world;
ShadowPlayer.m_pWorld = &world;
ShadowPlayer.Reset();
ShadowPlayer.Read(&buf);
CNetObj_CharacterCore next;
ShadowPlayer.Write(&next);
vec2 Prev = m_pClient->m_aClients[pPlayerInfo->m_ClientId].m_PreviousPrediction;
vec2 NextVec = vec2(next.m_X, next.m_Y);
vec2 ShadowPosition = NextVec;
float dist = distance(NextVec, Prev);
if (dist < 0) dist *= -1;
if (dist < 300) // like it should be usual
ShadowPosition = mix(Prev, NextVec, Client()->PredIntraGameTick());
m_pClient->m_aClients[pPlayerInfo->m_ClientId].m_PreviousPrediction = ShadowPosition;
CTeeRenderInfo shadow = RenderInfo;
float color_body_mix = (shadow.m_ColorBody.r + shadow.m_ColorBody.g + shadow.m_ColorBody.b) / 2.5f;
float color_feet_mix = (shadow.m_ColorFeet.r + shadow.m_ColorFeet.g + shadow.m_ColorFeet.b) / 2.5f;
shadow.m_ColorBody.a = 0.25f;
shadow.m_ColorFeet.a = 0.25f;
shadow.m_ColorBody.r = color_body_mix;
shadow.m_ColorBody.g = color_body_mix;
shadow.m_ColorBody.b = color_body_mix;
shadow.m_ColorFeet.r = color_feet_mix;
shadow.m_ColorFeet.g = color_feet_mix;
shadow.m_ColorFeet.b = color_feet_mix;
shadow.m_Texture = m_pClient->m_pSkins->Get(m_pClient->m_aClients[pPlayerInfo->m_ClientId].m_SkinId)->m_ColorTexture;
// Render shadow
RenderTools()->RenderTee(&State, &shadow, Player.m_Emote, Direction, ShadowPosition);
}
//---
// render the "shadow" tee
if(pInfo.m_Local && (g_Config.m_ClShowGhost || g_Config.m_Debug))
{
vec2 GhostPosition = mix(vec2(pPrevChar->m_X, pPrevChar->m_Y), vec2(pPlayerChar->m_X, pPlayerChar->m_Y), Client()->IntraGameTick());
CTeeRenderInfo Ghost = RenderInfo;
Ghost.m_ColorBody.a = 0.5f;
Ghost.m_ColorFeet.a = 0.5f;
RenderTools()->RenderTee(&State, &Ghost, Player.m_Emote, Direction, GhostPosition); // render ghost
}
RenderInfo.m_Size = 64.0f; // force some settings
RenderInfo.m_ColorBody.a = 1.0f;
RenderInfo.m_ColorFeet.a = 1.0f;
RenderTools()->RenderTee(&State, &RenderInfo, Player.m_Emote, Direction, Position);
if(Player.m_PlayerState == PLAYERSTATE_CHATTING)
{
Graphics()->TextureSet(g_pData->m_aImages[IMAGE_EMOTICONS].m_Id);
Graphics()->QuadsBegin();
RenderTools()->SelectSprite(SPRITE_DOTDOT);
IGraphics::CQuadItem QuadItem(Position.x + 24, Position.y - 40, 64,64);
Graphics()->QuadsDraw(&QuadItem, 1);
Graphics()->QuadsEnd();
}
if (m_pClient->m_aClients[pInfo.m_ClientId].m_EmoticonStart != -1 && m_pClient->m_aClients[pInfo.m_ClientId].m_EmoticonStart + 2 * Client()->GameTickSpeed() > Client()->GameTick())
{
Graphics()->TextureSet(g_pData->m_aImages[IMAGE_EMOTICONS].m_Id);
Graphics()->QuadsBegin();
int SinceStart = Client()->GameTick() - m_pClient->m_aClients[pInfo.m_ClientId].m_EmoticonStart;
int FromEnd = m_pClient->m_aClients[pInfo.m_ClientId].m_EmoticonStart + 2 * Client()->GameTickSpeed() - Client()->GameTick();
float a = 1;
if (FromEnd < Client()->GameTickSpeed() / 5)
a = FromEnd / (Client()->GameTickSpeed() / 5.0);
float h = 1;
if (SinceStart < Client()->GameTickSpeed() / 10)
h = SinceStart / (Client()->GameTickSpeed() / 10.0);
float Wiggle = 0;
if (SinceStart < Client()->GameTickSpeed() / 5)
Wiggle = SinceStart / (Client()->GameTickSpeed() / 5.0);
float WiggleAngle = sinf(5*Wiggle);
Graphics()->QuadsSetRotation(pi/6*WiggleAngle);
Graphics()->SetColor(1.0f,1.0f,1.0f,a);
// client_datas::emoticon is an offset from the first emoticon
RenderTools()->SelectSprite(SPRITE_OOP + m_pClient->m_aClients[pInfo.m_ClientId].m_Emoticon);
IGraphics::CQuadItem QuadItem(Position.x, Position.y - 23 - 32*h, 64, 64*h);
Graphics()->QuadsDraw(&QuadItem, 1);
Graphics()->QuadsEnd();
}
}
// TODO: render the minimap in a framebuffer and just draw the frambuffer texture
// most of the time, updating the framebuffer twice a frame.
// Here it updates as ping-pong either texture or vertex array each sec to lower gpu stalling
// (those operations cause a gpu sync, which slows down the way gpu works)
void CMiniMap::Draw()
{
PROFILE3("render minimap");
// The terrain isn't actually initialized until the map is loaded, which
// happens when the game is started, so abort until then.
if(!(GetGUI() && g_Game && g_Game->IsGameStarted()))
return;
CSimulation2* sim = g_Game->GetSimulation2();
CmpPtr<ICmpRangeManager> cmpRangeManager(*sim, SYSTEM_ENTITY);
ENSURE(cmpRangeManager);
// Set our globals in case they hadn't been set before
m_Camera = g_Game->GetView()->GetCamera();
m_Terrain = g_Game->GetWorld()->GetTerrain();
m_Width = (u32)(m_CachedActualSize.right - m_CachedActualSize.left);
m_Height = (u32)(m_CachedActualSize.bottom - m_CachedActualSize.top);
m_MapSize = m_Terrain->GetVerticesPerSide();
m_TextureSize = (GLsizei)round_up_to_pow2((size_t)m_MapSize);
m_MapScale = (cmpRangeManager->GetLosCircular() ? 1.f : 1.414f);
if(!m_TerrainTexture || g_GameRestarted)
CreateTextures();
// only update 2x / second
// (note: since units only move a few pixels per second on the minimap,
// we can get away with infrequent updates; this is slow)
// TODO: store frequency in a config file?
static double last_time;
const double cur_time = timer_Time();
const bool doUpdate = cur_time - last_time > 0.5;
if(doUpdate)
{
last_time = cur_time;
if(m_TerrainDirty)
RebuildTerrainTexture();
}
glMatrixMode(GL_PROJECTION);
glPushMatrix();
glLoadIdentity();
glMatrixMode(GL_MODELVIEW);
glPushMatrix();
CMatrix3D matrix = GetDefaultGuiMatrix();
glLoadMatrixf(&matrix._11);
// Disable depth updates to prevent apparent z-fighting-related issues
// with some drivers causing units to get drawn behind the texture
glDepthMask(0);
CShaderProgramPtr shader;
CShaderTechniquePtr tech;
if (g_Renderer.GetRenderPath() == CRenderer::RP_SHADER)
{
CShaderDefines defines;
defines.Add(str_MINIMAP_BASE, str_1);
tech = g_Renderer.GetShaderManager().LoadEffect(str_minimap, g_Renderer.GetSystemShaderDefines(), defines);
tech->BeginPass();
shader = tech->GetShader();
}
const float x = m_CachedActualSize.left, y = m_CachedActualSize.bottom;
const float x2 = m_CachedActualSize.right, y2 = m_CachedActualSize.top;
const float z = GetBufferedZ();
const float texCoordMax = (float)(m_MapSize - 1) / (float)m_TextureSize;
const float angle = GetAngle();
// Draw the main textured quad
if (g_Renderer.GetRenderPath() == CRenderer::RP_SHADER)
shader->BindTexture(str_baseTex, m_TerrainTexture);
else
g_Renderer.BindTexture(0, m_TerrainTexture);
glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
DrawTexture(shader, texCoordMax, angle, x, y, x2, y2, z);
// Draw territory boundaries
CTerritoryTexture& territoryTexture = g_Game->GetView()->GetTerritoryTexture();
if (g_Renderer.GetRenderPath() == CRenderer::RP_SHADER)
shader->BindTexture(str_baseTex, territoryTexture.GetTexture());
else
territoryTexture.BindTexture(0);
glEnable(GL_BLEND);
glMatrixMode(GL_TEXTURE);
glLoadMatrixf(territoryTexture.GetMinimapTextureMatrix());
glMatrixMode(GL_MODELVIEW);
DrawTexture(shader, 1.0f, angle, x, y, x2, y2, z);
glMatrixMode(GL_TEXTURE);
glLoadIdentity();
glMatrixMode(GL_MODELVIEW);
glDisable(GL_BLEND);
// Draw the LOS quad in black, using alpha values from the LOS texture
CLOSTexture& losTexture = g_Game->GetView()->GetLOSTexture();
if (g_Renderer.GetRenderPath() == CRenderer::RP_SHADER)
{
tech->EndPass();
CShaderDefines defines;
defines.Add(str_MINIMAP_LOS, str_1);
tech = g_Renderer.GetShaderManager().LoadEffect(str_minimap, g_Renderer.GetSystemShaderDefines(), defines);
tech->BeginPass();
shader = tech->GetShader();
shader->BindTexture(str_baseTex, losTexture.GetTexture());
}
else
{
losTexture.BindTexture(0);
}
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE);
glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB_ARB, GL_REPLACE);
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_RGB_ARB, GL_PRIMARY_COLOR_ARB);
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_RGB_ARB, GL_SRC_COLOR);
glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_ALPHA_ARB, GL_REPLACE);
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_ALPHA_ARB, GL_TEXTURE);
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_ALPHA_ARB, GL_ONE_MINUS_SRC_ALPHA);
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glColor3f(0.0f, 0.0f, 0.0f);
glMatrixMode(GL_TEXTURE);
glLoadMatrixf(losTexture.GetMinimapTextureMatrix());
glMatrixMode(GL_MODELVIEW);
DrawTexture(shader, 1.0f, angle, x, y, x2, y2, z);
glMatrixMode(GL_TEXTURE);
glLoadIdentity();
glMatrixMode(GL_MODELVIEW);
glDisable(GL_BLEND);
if (g_Renderer.GetRenderPath() == CRenderer::RP_SHADER)
{
tech->EndPass();
CShaderDefines defines;
defines.Add(str_MINIMAP_POINT, str_1);
tech = g_Renderer.GetShaderManager().LoadEffect(str_minimap, g_Renderer.GetSystemShaderDefines(), defines);
tech->BeginPass();
shader = tech->GetShader();
}
// Set up the matrix for drawing points and lines
glPushMatrix();
glTranslatef(x, y, z);
// Rotate around the center of the map
glTranslatef((x2-x)/2.f, (y2-y)/2.f, 0.f);
// Scale square maps to fit in circular minimap area
float unitScale = (cmpRangeManager->GetLosCircular() ? 1.f : m_MapScale/2.f);
glScalef(unitScale, unitScale, 1.f);
glRotatef(angle * 180.f/M_PI, 0.f, 0.f, 1.f);
glTranslatef(-(x2-x)/2.f, -(y2-y)/2.f, 0.f);
PROFILE_START("minimap units");
const float sx = (float)m_Width / ((m_MapSize - 1) * TERRAIN_TILE_SIZE);
const float sy = (float)m_Height / ((m_MapSize - 1) * TERRAIN_TILE_SIZE);
CSimulation2::InterfaceList ents = sim->GetEntitiesWithInterface(IID_Minimap);
if (doUpdate)
{
VertexArrayIterator<float[2]> attrPos = m_AttributePos.GetIterator<float[2]>();
VertexArrayIterator<u8[4]> attrColor = m_AttributeColor.GetIterator<u8[4]>();
m_EntitiesDrawn = 0;
MinimapUnitVertex v;
std::vector<MinimapUnitVertex> pingingVertices;
pingingVertices.reserve(MAX_ENTITIES_DRAWN/2);
const double time = timer_Time();
if (time > m_NextBlinkTime)
{
m_BlinkState = !m_BlinkState;
m_NextBlinkTime = time + m_HalfBlinkDuration;
}
entity_pos_t posX, posZ;
for (CSimulation2::InterfaceList::const_iterator it = ents.begin(); it != ents.end(); ++it)
{
ICmpMinimap* cmpMinimap = static_cast<ICmpMinimap*>(it->second);
if (cmpMinimap->GetRenderData(v.r, v.g, v.b, posX, posZ))
{
ICmpRangeManager::ELosVisibility vis = cmpRangeManager->GetLosVisibility(it->first, g_Game->GetPlayerID());
if (vis != ICmpRangeManager::VIS_HIDDEN)
{
v.a = 255;
v.x = posX.ToFloat()*sx;
v.y = -posZ.ToFloat()*sy;
// Check minimap pinging to indicate something
if (m_BlinkState && cmpMinimap->CheckPing(time, m_PingDuration))
{
v.r = 255; // ping color is white
v.g = 255;
v.b = 255;
pingingVertices.push_back(v);
}
else
{
addVertex(v, attrColor, attrPos);
++m_EntitiesDrawn;
}
}
}
}
// Add the pinged vertices at the end, so they are drawn on top
for (size_t v = 0; v < pingingVertices.size(); ++v)
{
addVertex(pingingVertices[v], attrColor, attrPos);
++m_EntitiesDrawn;
}
ENSURE(m_EntitiesDrawn < MAX_ENTITIES_DRAWN);
m_VertexArray.Upload();
}
if (m_EntitiesDrawn > 0)
{
// Don't enable GL_POINT_SMOOTH because it's far too slow
// (~70msec/frame on a GF4 rendering a thousand points)
glPointSize(3.f);
u8* indexBase = m_IndexArray.Bind();
u8* base = m_VertexArray.Bind();
const GLsizei stride = (GLsizei)m_VertexArray.GetStride();
if (g_Renderer.GetRenderPath() == CRenderer::RP_SHADER)
{
shader->VertexPointer(2, GL_FLOAT, stride, base + m_AttributePos.offset);
shader->ColorPointer(4, GL_UNSIGNED_BYTE, stride, base + m_AttributeColor.offset);
shader->AssertPointersBound();
}
else
{
glEnableClientState(GL_VERTEX_ARRAY);
glEnableClientState(GL_COLOR_ARRAY);
glDisable(GL_TEXTURE_2D);
glVertexPointer(2, GL_FLOAT, stride, base + m_AttributePos.offset);
glColorPointer(4, GL_UNSIGNED_BYTE, stride, base + m_AttributeColor.offset);
}
if (!g_Renderer.m_SkipSubmit)
{
glDrawElements(GL_POINTS, (GLsizei)(m_EntitiesDrawn), GL_UNSIGNED_SHORT, indexBase);
}
g_Renderer.GetStats().m_DrawCalls++;
CVertexBuffer::Unbind();
}
PROFILE_END("minimap units");
if (g_Renderer.GetRenderPath() == CRenderer::RP_SHADER)
{
tech->EndPass();
CShaderDefines defines;
defines.Add(str_MINIMAP_LINE, str_1);
tech = g_Renderer.GetShaderManager().LoadEffect(str_minimap, g_Renderer.GetSystemShaderDefines(), defines);
tech->BeginPass();
shader = tech->GetShader();
}
else
{
glEnable(GL_TEXTURE_2D);
glDisableClientState(GL_VERTEX_ARRAY);
glDisableClientState(GL_COLOR_ARRAY);
}
DrawViewRect();
glPopMatrix();
glMatrixMode(GL_PROJECTION);
glPopMatrix();
glMatrixMode(GL_MODELVIEW);
glPopMatrix();
if (g_Renderer.GetRenderPath() == CRenderer::RP_SHADER)
{
tech->EndPass();
}
// Reset everything back to normal
glPointSize(1.0f);
glEnable(GL_TEXTURE_2D);
glDepthMask(1);
}
// 이 함수.. 오브젝트 서브 클래스로 분리 예정..
void CMover::ProcessMove()
{
if( m_pActMover->IsSit() )
return;
EnforcedGhostCorr(); // 고스트의 강제 동기가 필요하다면 실행
ApproachGhostAngle(); // 고스트의 목표 각도로의 점진적인 각도의 변경
if( IsEmptyDest() )
return;
if( m_pActMover->IsActAttack() )
return;
D3DXVECTOR3 vPos = GetPos();
D3DXVECTOR3 vDestPos = m_vDestPos;
if( !IsEmptyDestPos() ) // 좌표
{
bool bPositiveX = ( (vPos.x - vDestPos.x) > 0.0f );
bool bPositiveZ = ( (vPos.z - vDestPos.z) > 0.0f );
#ifdef __BS_FIX_ARRIVEPOS_ALGO // 마우스 목적좌표 이동시 절대축과 같은경우 중간에 멈추는 현상이 있었다.
if( ( bPositiveX != m_bPositiveX || bPositiveZ != m_bPositiveZ ) )
{
if( IsActiveMover( ) )
{
D3DXVECTOR3 kDir = vPos - vDestPos ;
D3DXVec3Normalize( &kDir, &kDir );
D3DXVECTOR3 kMyDir;
AngleToVectorXZ( &kMyDir, GetAngle(), 1.0f );
D3DXVec3Normalize( &kMyDir, &kMyDir );
float fAngle = D3DXVec3Dot( &kDir, &kMyDir );
if( fAngle > 0.0f )
{
OnArriveAtPos( );
return;
}
}
else
{
OnArriveAtPos( );
return;
}
}
#else
if( ( bPositiveX != m_bPositiveX || bPositiveZ != m_bPositiveZ ) )
{
OnArriveAtPos(); // 좌표에 도착했을 때의 처리
return;
}
#endif
}
else // 오브젝트
{
CCtrl* pObj = prj.GetCtrl( m_idDest );
if( IsValidObj( pObj ) == FALSE )
{
SendActMsg( OBJMSG_STAND );
return;
}
vDestPos = pObj->GetPos();
if( m_pActMover->IsFly() )
{
BOOL bRangeObj = pObj->IsRangeObj( this, m_fArrivalRange );
if( bRangeObj == TRUE )
{
ClearDestObj(); // 그외는 목표에 도착하면 멈춤.
#ifdef __WORLDSERVER
OnArrive( pObj->GetId(), 0 );
#endif // __WORLDSERVER
}
}
else
{
if( pObj->IsRangeObj( this, m_fArrivalRange ) ) // 3D 충돌에 실패했지만
{
ProcessMoveArrival( pObj );
return;
}
}
}
// 공중 추적
if( m_pActMover->IsFly() )
{
if( m_uRemnantCorrFrm > 0 )
{
D3DXVECTOR3 v = vDestPos - vPos;
m_pActMover->m_fDistance = D3DXVec3Length( &v );
SendActMsg( OBJMSG_TURNMOVE, (int)GetDegree( vDestPos, vPos ), (int)GetDegreeX( vDestPos, vPos ), 0 );
m_uRemnantCorrFrm--;
}
}
else
{
if( m_uRemnantCorrFrm > 0 )
m_uRemnantCorrFrm--;
if( m_bForward )
SendActMsg( OBJMSG_TURNMOVE, (int)GetDegree( vDestPos, vPos ), (int)GetDegreeX( vDestPos, vPos ) );
else
SendActMsg( OBJMSG_TURNMOVE2, (int)GetDegree( vPos, vDestPos ), (int)GetDegreeX( vPos, vDestPos ) );
}
}
void QtArrowItem::paint(QPainter *painter, const QStyleOptionGraphicsItem *, QWidget *)
{
painter->setRenderHint(QPainter::Antialiasing);
if (this->isSelected())
{
const QColor color(255,0,0);
QPen pen;
pen.setColor(color);
pen.setWidth(3);
painter->setPen(pen);
QBrush brush;
brush.setColor(color);
brush.setStyle(Qt::SolidPattern);
painter->setBrush(brush);
}
else
{
const QColor color(0,0,0);
QPen pen;
pen.setColor(color);
pen.setWidth(1);
painter->setPen(pen);
QBrush brush;
brush.setColor(color);
brush.setStyle(Qt::SolidPattern);
painter->setBrush(brush);
}
painter->drawLine(this->line());
//The angle from tail to head
double angle = GetAngle(line().dx(),line().dy());
if (line().dy() >= 0.0) angle = (1.0 * boost::math::constants::pi<double>()) + angle;
const double sz = 10.0; //pixels
if (m_tail)
{
const QPointF p0 = this->line().p1();
const QPointF p1
= p0 + QPointF(
std::sin(angle + boost::math::constants::pi<double>() + (boost::math::constants::pi<double>() * 0.1)) * sz,
-std::cos(angle + boost::math::constants::pi<double>() + (boost::math::constants::pi<double>() * 0.1)) * sz);
const QPointF p2
= p0 + QPointF(
std::sin(angle + boost::math::constants::pi<double>() - (boost::math::constants::pi<double>() * 0.1)) * sz,
-std::cos(angle + boost::math::constants::pi<double>() - (boost::math::constants::pi<double>() * 0.1)) * sz);
painter->drawPolygon(QPolygonF() << p0 << p1 << p2);
}
if (m_head)
{
const QPointF p0 = this->line().p2();
const QPointF p1
= p0 + QPointF(
std::sin(angle + 0.0 + (boost::math::constants::pi<double>() * 0.1)) * sz,
-std::cos(angle + 0.0 + (boost::math::constants::pi<double>() * 0.1)) * sz);
const QPointF p2
= p0 + QPointF(
std::sin(angle + 0.0 - (boost::math::constants::pi<double>() * 0.1)) * sz,
-std::cos(angle + 0.0 - (boost::math::constants::pi<double>() * 0.1)) * sz);
painter->drawPolygon(QPolygonF() << p0 << p1 << p2);
}
}
void CPlayers::RenderPlayer(
const CNetObj_Character *pPrevChar,
const CNetObj_Character *pPlayerChar,
const CNetObj_PlayerInfo *pPrevInfo,
const CNetObj_PlayerInfo *pPlayerInfo
)
{
CNetObj_Character Prev;
CNetObj_Character Player;
Prev = *pPrevChar;
Player = *pPlayerChar;
CNetObj_PlayerInfo pInfo = *pPlayerInfo;
CTeeRenderInfo RenderInfo = m_aRenderInfo[pInfo.m_ClientID];
bool NewTick = m_pClient->m_NewTick;
// set size
RenderInfo.m_Size = 64.0f;
float IntraTick = Client()->IntraGameTick();
float Angle = mix((float)Prev.m_Angle, (float)Player.m_Angle, IntraTick)/256.0f;
//float angle = 0;
if(pInfo.m_Local && Client()->State() != IClient::STATE_DEMOPLAYBACK)
{
// just use the direct input if it's local player we are rendering
Angle = GetAngle(m_pClient->m_pControls->m_MousePos);
}
else
{
/*
float mixspeed = Client()->FrameTime()*2.5f;
if(player.attacktick != prev.attacktick) // shooting boosts the mixing speed
mixspeed *= 15.0f;
// move the delta on a constant speed on a x^2 curve
float current = g_GameClient.m_aClients[info.cid].angle;
float target = player.angle/256.0f;
float delta = angular_distance(current, target);
float sign = delta < 0 ? -1 : 1;
float new_delta = delta - 2*mixspeed*sqrt(delta*sign)*sign + mixspeed*mixspeed;
// make sure that it doesn't vibrate when it's still
if(fabs(delta) < 2/256.0f)
angle = target;
else
angle = angular_approach(current, target, fabs(delta-new_delta));
g_GameClient.m_aClients[info.cid].angle = angle;*/
}
// use preditect players if needed
if(pInfo.m_Local && g_Config.m_ClPredict && Client()->State() != IClient::STATE_DEMOPLAYBACK)
{
if(!m_pClient->m_Snap.m_pLocalCharacter || (m_pClient->m_Snap.m_pGameInfoObj && m_pClient->m_Snap.m_pGameInfoObj->m_GameStateFlags&GAMESTATEFLAG_GAMEOVER))
{
}
else
{
// apply predicted results
m_pClient->m_PredictedChar.Write(&Player);
m_pClient->m_PredictedPrevChar.Write(&Prev);
IntraTick = Client()->PredIntraGameTick();
NewTick = m_pClient->m_NewPredictedTick;
}
}
vec2 Direction = GetDirection((int)(Angle*256.0f));
vec2 Position = mix(vec2(Prev.m_X, Prev.m_Y), vec2(Player.m_X, Player.m_Y), IntraTick);
vec2 Vel = mix(vec2(Prev.m_VelX/256.0f, Prev.m_VelY/256.0f), vec2(Player.m_VelX/256.0f, Player.m_VelY/256.0f), IntraTick);
m_pClient->m_pFlow->Add(Position, Vel*100.0f, 10.0f);
RenderInfo.m_GotAirJump = Player.m_Jumped&2?0:1;
// detect events
if(NewTick)
{
// detect air jump
if(!RenderInfo.m_GotAirJump && !(Prev.m_Jumped&2))
m_pClient->m_pEffects->AirJump(Position);
}
bool Stationary = Player.m_VelX <= 1 && Player.m_VelX >= -1;
bool InAir = !Collision()->CheckPoint(Player.m_X, Player.m_Y+16);
bool WantOtherDir = (Player.m_Direction == -1 && Vel.x > 0) || (Player.m_Direction == 1 && Vel.x < 0);
// evaluate animation
float WalkTime = fmod(absolute(Position.x), 100.0f)/100.0f;
CAnimState State;
State.Set(&g_pData->m_aAnimations[ANIM_BASE], 0);
if(InAir)
State.Add(&g_pData->m_aAnimations[ANIM_INAIR], 0, 1.0f); // TODO: some sort of time here
else if(Stationary)
State.Add(&g_pData->m_aAnimations[ANIM_IDLE], 0, 1.0f); // TODO: some sort of time here
else if(!WantOtherDir)
State.Add(&g_pData->m_aAnimations[ANIM_WALK], WalkTime, 1.0f);
static float s_LastGameTickTime = Client()->GameTickTime();
if(m_pClient->m_Snap.m_pGameInfoObj && !(m_pClient->m_Snap.m_pGameInfoObj->m_GameStateFlags&GAMESTATEFLAG_PAUSED))
s_LastGameTickTime = Client()->GameTickTime();
if (Player.m_Weapon == WEAPON_HAMMER)
{
float ct = (Client()->PrevGameTick()-Player.m_AttackTick)/(float)SERVER_TICK_SPEED + s_LastGameTickTime;
State.Add(&g_pData->m_aAnimations[ANIM_HAMMER_SWING], clamp(ct*5.0f,0.0f,1.0f), 1.0f);
}
if (Player.m_Weapon == WEAPON_NINJA)
{
float ct = (Client()->PrevGameTick()-Player.m_AttackTick)/(float)SERVER_TICK_SPEED + s_LastGameTickTime;
State.Add(&g_pData->m_aAnimations[ANIM_NINJA_SWING], clamp(ct*2.0f,0.0f,1.0f), 1.0f);
}
// do skidding
if(!InAir && WantOtherDir && length(Vel*50) > 500.0f)
{
static int64 SkidSoundTime = 0;
if(time_get()-SkidSoundTime > time_freq()/10)
{
m_pClient->m_pSounds->PlayAt(CSounds::CHN_WORLD, SOUND_PLAYER_SKID, 0.25f, Position);
SkidSoundTime = time_get();
}
m_pClient->m_pEffects->SkidTrail(
Position+vec2(-Player.m_Direction*6,12),
vec2(-Player.m_Direction*100*length(Vel),-50)
);
}
// draw gun
{
Graphics()->TextureSet(g_pData->m_aImages[IMAGE_GAME].m_Id);
Graphics()->QuadsBegin();
Graphics()->QuadsSetRotation(State.GetAttach()->m_Angle*pi*2+Angle);
// normal weapons
int iw = clamp(Player.m_Weapon, 0, NUM_WEAPONS-1);
RenderTools()->SelectSprite(g_pData->m_Weapons.m_aId[iw].m_pSpriteBody, Direction.x < 0 ? SPRITE_FLAG_FLIP_Y : 0);
vec2 Dir = Direction;
float Recoil = 0.0f;
vec2 p;
if (Player.m_Weapon == WEAPON_HAMMER)
{
// Static position for hammer
p = Position + vec2(State.GetAttach()->m_X, State.GetAttach()->m_Y);
p.y += g_pData->m_Weapons.m_aId[iw].m_Offsety;
// if attack is under way, bash stuffs
if(Direction.x < 0)
{
Graphics()->QuadsSetRotation(-pi/2-State.GetAttach()->m_Angle*pi*2);
p.x -= g_pData->m_Weapons.m_aId[iw].m_Offsetx;
}
else
{
Graphics()->QuadsSetRotation(-pi/2+State.GetAttach()->m_Angle*pi*2);
}
RenderTools()->DrawSprite(p.x, p.y, g_pData->m_Weapons.m_aId[iw].m_VisualSize);
}
else if (Player.m_Weapon == WEAPON_NINJA)
{
p = Position;
p.y += g_pData->m_Weapons.m_aId[iw].m_Offsety;
if(Direction.x < 0)
{
Graphics()->QuadsSetRotation(-pi/2-State.GetAttach()->m_Angle*pi*2);
p.x -= g_pData->m_Weapons.m_aId[iw].m_Offsetx;
m_pClient->m_pEffects->PowerupShine(p+vec2(32,0), vec2(32,12));
}
else
{
Graphics()->QuadsSetRotation(-pi/2+State.GetAttach()->m_Angle*pi*2);
m_pClient->m_pEffects->PowerupShine(p-vec2(32,0), vec2(32,12));
}
RenderTools()->DrawSprite(p.x, p.y, g_pData->m_Weapons.m_aId[iw].m_VisualSize);
// HADOKEN
if ((Client()->GameTick()-Player.m_AttackTick) <= (SERVER_TICK_SPEED / 6) && g_pData->m_Weapons.m_aId[iw].m_NumSpriteMuzzles)
{
int IteX = rand() % g_pData->m_Weapons.m_aId[iw].m_NumSpriteMuzzles;
static int s_LastIteX = IteX;
if(Client()->State() == IClient::STATE_DEMOPLAYBACK)
{
const IDemoPlayer::CInfo *pInfo = DemoPlayer()->BaseInfo();
if(pInfo->m_Paused)
IteX = s_LastIteX;
else
s_LastIteX = IteX;
}
else
{
if(m_pClient->m_Snap.m_pGameInfoObj && m_pClient->m_Snap.m_pGameInfoObj->m_GameStateFlags&GAMESTATEFLAG_PAUSED)
IteX = s_LastIteX;
else
s_LastIteX = IteX;
}
if(g_pData->m_Weapons.m_aId[iw].m_aSpriteMuzzles[IteX])
{
vec2 Dir = vec2(pPlayerChar->m_X,pPlayerChar->m_Y) - vec2(pPrevChar->m_X, pPrevChar->m_Y);
Dir = normalize(Dir);
float HadOkenAngle = GetAngle(Dir);
Graphics()->QuadsSetRotation(HadOkenAngle );
//float offsety = -data->weapons[iw].muzzleoffsety;
RenderTools()->SelectSprite(g_pData->m_Weapons.m_aId[iw].m_aSpriteMuzzles[IteX], 0);
vec2 DirY(-Dir.y,Dir.x);
p = Position;
float OffsetX = g_pData->m_Weapons.m_aId[iw].m_Muzzleoffsetx;
p -= Dir * OffsetX;
RenderTools()->DrawSprite(p.x, p.y, 160.0f);
}
}
}
else
{
// TODO: should be an animation
Recoil = 0;
static float s_LastIntraTick = IntraTick;
if(m_pClient->m_Snap.m_pGameInfoObj && !(m_pClient->m_Snap.m_pGameInfoObj->m_GameStateFlags&GAMESTATEFLAG_PAUSED))
s_LastIntraTick = IntraTick;
float a = (Client()->GameTick()-Player.m_AttackTick+s_LastIntraTick)/5.0f;
if(a < 1)
Recoil = sinf(a*pi);
p = Position + Dir * g_pData->m_Weapons.m_aId[iw].m_Offsetx - Dir*Recoil*10.0f;
p.y += g_pData->m_Weapons.m_aId[iw].m_Offsety;
RenderTools()->DrawSprite(p.x, p.y, g_pData->m_Weapons.m_aId[iw].m_VisualSize);
}
if (Player.m_Weapon == WEAPON_GUN || Player.m_Weapon == WEAPON_SHOTGUN)
{
// check if we're firing stuff
if(g_pData->m_Weapons.m_aId[iw].m_NumSpriteMuzzles)//prev.attackticks)
{
float Alpha = 0.0f;
int Phase1Tick = (Client()->GameTick() - Player.m_AttackTick);
if (Phase1Tick < (g_pData->m_Weapons.m_aId[iw].m_Muzzleduration + 3))
{
float t = ((((float)Phase1Tick) + IntraTick)/(float)g_pData->m_Weapons.m_aId[iw].m_Muzzleduration);
Alpha = mix(2.0f, 0.0f, min(1.0f,max(0.0f,t)));
}
int IteX = rand() % g_pData->m_Weapons.m_aId[iw].m_NumSpriteMuzzles;
static int s_LastIteX = IteX;
if(Client()->State() == IClient::STATE_DEMOPLAYBACK)
{
const IDemoPlayer::CInfo *pInfo = DemoPlayer()->BaseInfo();
if(pInfo->m_Paused)
IteX = s_LastIteX;
else
s_LastIteX = IteX;
}
else
{
if(m_pClient->m_Snap.m_pGameInfoObj && m_pClient->m_Snap.m_pGameInfoObj->m_GameStateFlags&GAMESTATEFLAG_PAUSED)
IteX = s_LastIteX;
else
s_LastIteX = IteX;
}
if (Alpha > 0.0f && g_pData->m_Weapons.m_aId[iw].m_aSpriteMuzzles[IteX])
{
float OffsetY = -g_pData->m_Weapons.m_aId[iw].m_Muzzleoffsety;
RenderTools()->SelectSprite(g_pData->m_Weapons.m_aId[iw].m_aSpriteMuzzles[IteX], Direction.x < 0 ? SPRITE_FLAG_FLIP_Y : 0);
if(Direction.x < 0)
OffsetY = -OffsetY;
vec2 DirY(-Dir.y,Dir.x);
vec2 MuzzlePos = p + Dir * g_pData->m_Weapons.m_aId[iw].m_Muzzleoffsetx + DirY * OffsetY;
RenderTools()->DrawSprite(MuzzlePos.x, MuzzlePos.y, g_pData->m_Weapons.m_aId[iw].m_VisualSize);
}
}
}
Graphics()->QuadsEnd();
switch (Player.m_Weapon)
{
case WEAPON_GUN: RenderHand(&RenderInfo, p, Direction, -3*pi/4, vec2(-15, 4)); break;
case WEAPON_SHOTGUN: RenderHand(&RenderInfo, p, Direction, -pi/2, vec2(-5, 4)); break;
case WEAPON_GRENADE: RenderHand(&RenderInfo, p, Direction, -pi/2, vec2(-4, 7)); break;
}
}
// render the "shadow" tee
if(pInfo.m_Local && g_Config.m_Debug)
{
vec2 GhostPosition = mix(vec2(pPrevChar->m_X, pPrevChar->m_Y), vec2(pPlayerChar->m_X, pPlayerChar->m_Y), Client()->IntraGameTick());
CTeeRenderInfo Ghost = RenderInfo;
Ghost.m_ColorBody.a = 0.5f;
Ghost.m_ColorFeet.a = 0.5f;
RenderTools()->RenderTee(&State, &Ghost, Player.m_Emote, Direction, GhostPosition); // render ghost
}
RenderInfo.m_Size = 64.0f; // force some settings
RenderInfo.m_ColorBody.a = 1.0f;
RenderInfo.m_ColorFeet.a = 1.0f;
RenderTools()->RenderTee(&State, &RenderInfo, Player.m_Emote, Direction, Position);
if(Player.m_PlayerFlags&PLAYERFLAG_CHATTING)
{
Graphics()->TextureSet(g_pData->m_aImages[IMAGE_EMOTICONS].m_Id);
Graphics()->QuadsBegin();
RenderTools()->SelectSprite(SPRITE_DOTDOT);
IGraphics::CQuadItem QuadItem(Position.x + 24, Position.y - 40, 64,64);
Graphics()->QuadsDraw(&QuadItem, 1);
Graphics()->QuadsEnd();
}
if (m_pClient->m_aClients[pInfo.m_ClientID].m_EmoticonStart != -1 && m_pClient->m_aClients[pInfo.m_ClientID].m_EmoticonStart + 2 * Client()->GameTickSpeed() > Client()->GameTick())
{
Graphics()->TextureSet(g_pData->m_aImages[IMAGE_EMOTICONS].m_Id);
Graphics()->QuadsBegin();
int SinceStart = Client()->GameTick() - m_pClient->m_aClients[pInfo.m_ClientID].m_EmoticonStart;
int FromEnd = m_pClient->m_aClients[pInfo.m_ClientID].m_EmoticonStart + 2 * Client()->GameTickSpeed() - Client()->GameTick();
float a = 1;
if (FromEnd < Client()->GameTickSpeed() / 5)
a = FromEnd / (Client()->GameTickSpeed() / 5.0);
float h = 1;
if (SinceStart < Client()->GameTickSpeed() / 10)
h = SinceStart / (Client()->GameTickSpeed() / 10.0);
float Wiggle = 0;
if (SinceStart < Client()->GameTickSpeed() / 5)
Wiggle = SinceStart / (Client()->GameTickSpeed() / 5.0);
float WiggleAngle = sinf(5*Wiggle);
Graphics()->QuadsSetRotation(pi/6*WiggleAngle);
Graphics()->SetColor(1.0f,1.0f,1.0f,a);
// client_datas::emoticon is an offset from the first emoticon
RenderTools()->SelectSprite(SPRITE_OOP + m_pClient->m_aClients[pInfo.m_ClientID].m_Emoticon);
IGraphics::CQuadItem QuadItem(Position.x, Position.y - 23 - 32*h, 64, 64*h);
Graphics()->QuadsDraw(&QuadItem, 1);
Graphics()->QuadsEnd();
}
}
void CPlayers::RenderHook(
const CNetObj_Character *pPrevChar,
const CNetObj_Character *pPlayerChar,
const CNetObj_PlayerInfo *pPrevInfo,
const CNetObj_PlayerInfo *pPlayerInfo
)
{
CNetObj_Character Prev;
CNetObj_Character Player;
Prev = *pPrevChar;
Player = *pPlayerChar;
CNetObj_PlayerInfo pInfo = *pPlayerInfo;
CTeeRenderInfo RenderInfo = m_aRenderInfo[pInfo.m_ClientID];
float IntraTick = Client()->IntraGameTick();
// set size
RenderInfo.m_Size = 64.0f;
// use preditect players if needed
if(pInfo.m_Local && g_Config.m_ClPredict && Client()->State() != IClient::STATE_DEMOPLAYBACK)
{
if(!m_pClient->m_Snap.m_pLocalCharacter || (m_pClient->m_Snap.m_pGameInfoObj && m_pClient->m_Snap.m_pGameInfoObj->m_GameStateFlags&GAMESTATEFLAG_GAMEOVER))
{
}
else
{
// apply predicted results
m_pClient->m_PredictedChar.Write(&Player);
m_pClient->m_PredictedPrevChar.Write(&Prev);
IntraTick = Client()->PredIntraGameTick();
}
}
vec2 Position = mix(vec2(Prev.m_X, Prev.m_Y), vec2(Player.m_X, Player.m_Y), IntraTick);
// draw hook
if (Prev.m_HookState>0 && Player.m_HookState>0)
{
Graphics()->TextureSet(g_pData->m_aImages[IMAGE_GAME].m_Id);
Graphics()->QuadsBegin();
//Graphics()->QuadsBegin();
vec2 Pos = Position;
vec2 HookPos;
if(pPlayerChar->m_HookedPlayer != -1)
{
if(m_pClient->m_Snap.m_pLocalInfo && pPlayerChar->m_HookedPlayer == m_pClient->m_Snap.m_pLocalInfo->m_ClientID)
{
if(Client()->State() == IClient::STATE_DEMOPLAYBACK) // only use prediction if needed
HookPos = vec2(m_pClient->m_LocalCharacterPos.x, m_pClient->m_LocalCharacterPos.y);
else
HookPos = mix(vec2(m_pClient->m_PredictedPrevChar.m_Pos.x, m_pClient->m_PredictedPrevChar.m_Pos.y),
vec2(m_pClient->m_PredictedChar.m_Pos.x, m_pClient->m_PredictedChar.m_Pos.y), Client()->PredIntraGameTick());
}
else if(pInfo.m_Local)
{
HookPos = mix(vec2(m_pClient->m_Snap.m_aCharacters[pPlayerChar->m_HookedPlayer].m_Prev.m_X,
m_pClient->m_Snap.m_aCharacters[pPlayerChar->m_HookedPlayer].m_Prev.m_Y),
vec2(m_pClient->m_Snap.m_aCharacters[pPlayerChar->m_HookedPlayer].m_Cur.m_X,
m_pClient->m_Snap.m_aCharacters[pPlayerChar->m_HookedPlayer].m_Cur.m_Y),
Client()->IntraGameTick());
}
else
HookPos = mix(vec2(pPrevChar->m_HookX, pPrevChar->m_HookY), vec2(pPlayerChar->m_HookX, pPlayerChar->m_HookY), Client()->IntraGameTick());
}
else
HookPos = mix(vec2(Prev.m_HookX, Prev.m_HookY), vec2(Player.m_HookX, Player.m_HookY), IntraTick);
float d = distance(Pos, HookPos);
vec2 Dir = normalize(Pos-HookPos);
Graphics()->QuadsSetRotation(GetAngle(Dir)+pi);
// render head
RenderTools()->SelectSprite(SPRITE_HOOK_HEAD);
IGraphics::CQuadItem QuadItem(HookPos.x, HookPos.y, 24,16);
Graphics()->QuadsDraw(&QuadItem, 1);
// render chain
RenderTools()->SelectSprite(SPRITE_HOOK_CHAIN);
IGraphics::CQuadItem Array[1024];
int i = 0;
for(float f = 24; f < d && i < 1024; f += 24, i++)
{
vec2 p = HookPos + Dir*f;
Array[i] = IGraphics::CQuadItem(p.x, p.y,24,16);
}
Graphics()->QuadsDraw(Array, i);
Graphics()->QuadsSetRotation(0);
Graphics()->QuadsEnd();
RenderHand(&RenderInfo, Position, normalize(HookPos-Pos), -pi/2, vec2(20, 0));
}
}
// 패턴이동중.
void CMover::ProcessMovePattern( void )
{
if( m_nMovePattern == 1 ) // 8자이동 패턴.
{
switch( m_nMoveEvent )
{
case 0:
m_nMoveEvent ++;
m_nMoveEventCnt = 0;
// break; // break 넣지 말것.
case 1: // S - 1 구간 : n초간 좌회전중.
SendActMsg( OBJMSG_FORWARD );
if( (m_nMoveEventCnt & 3) == 0 )
SendActMsg( OBJMSG_LTURN );
else
SendActMsg( OBJMSG_STOP_TURN );
if( ++m_nMoveEventCnt > SEC1 * 2 )
{
m_nMoveEventCnt = 0;
m_nMoveEvent ++;
// SendActMsg( OBJMSG_STOP );
}
break;
case 2: // 1 - 2구간 : n초간 우회전하며 상승했다 하강.
SendActMsg( OBJMSG_FORWARD );
if( (m_nMoveEventCnt & 3) == 0 )
SendActMsg( OBJMSG_RTURN );
else
SendActMsg( OBJMSG_STOP_TURN );
if( m_nMoveEventCnt < (SEC1 * 5) / 2 )
{
SendActMsg( OBJMSG_LOOKUP );
} else
if( m_nMoveEventCnt == (SEC1 * 5) / 2 )
{
SendActMsg( OBJMSG_STOP_LOOK );
SetAngleX( 0 ); // 수평으로 맞춤.
} else
{
SendActMsg( OBJMSG_LOOKDOWN );
}
if( ++m_nMoveEventCnt > SEC1 * 5 )
{
m_nMoveEventCnt = 0;
m_nMoveEvent ++;
SendActMsg( OBJMSG_STOP_LOOK );
SendActMsg( OBJMSG_STOP_TURN );
SendActMsg( OBJMSG_STOP );
SetAngleX( 0 ); // 수평으로 맞춤.
}
break;
case 3: // 2 - 3구간 : 우회전 하다가 좌회전.
SendActMsg( OBJMSG_FORWARD );
if( m_nMoveEventCnt < (SEC1 * 5) / 2 ) //
{
if( (m_nMoveEventCnt & 3) == 0 )
SendActMsg( OBJMSG_RTURN );
else
SendActMsg( OBJMSG_STOP_TURN );
} else
{
if( (m_nMoveEventCnt & 3) == 0 )
SendActMsg( OBJMSG_LTURN );
else
SendActMsg( OBJMSG_STOP_TURN );
}
if( ++m_nMoveEventCnt > SEC1 * 5 )
{
m_nMoveEventCnt = 0;
m_nMoveEvent ++;
SendActMsg( OBJMSG_STOP_LOOK );
SendActMsg( OBJMSG_STOP_TURN );
SetAngleX( 0 ); // 수평으로 맞춤.
}
break;
case 4: // 3 - S구간 : 좌회전하면서 하강하다 상승
SendActMsg( OBJMSG_FORWARD );
if( (m_nMoveEventCnt & 3) == 0 )
SendActMsg( OBJMSG_LTURN );
else
SendActMsg( OBJMSG_STOP_TURN );
if( m_nMoveEventCnt < (SEC1 * 5) / 2 )
{
SendActMsg( OBJMSG_LOOKDOWN );
} else
if( m_nMoveEventCnt == (SEC1 * 5) / 2 )
{
SendActMsg( OBJMSG_STOP_LOOK );
SetAngleX( 0 ); // 수평으로 맞춤.
} else
{
SendActMsg( OBJMSG_LOOKUP );
}
if( ++m_nMoveEventCnt > SEC1 * 5 )
{
m_nMoveEventCnt = 0;
m_nMoveEvent = 99;
SendActMsg( OBJMSG_STOP_LOOK );
SendActMsg( OBJMSG_STOP_TURN );
SendActMsg( OBJMSG_STOP );
SetAngleX( 0 ); // 수평으로 맞춤.
}
break;
case 99:
break;
}
} else // movePattern 1
if( m_nMovePattern == 2 ) // 비행 패턴 2
{
switch( m_nMoveEvent )
{
case 0:
m_nMoveEvent ++;
m_nMoveEventCnt = 0;
// break; // break 넣지 말것.
case 1: // S - 1 구간중 직진 코스
SendActMsg( OBJMSG_FORWARD );
if( ++m_nMoveEventCnt > SEC1 ) // 1초가 지나면 급 우회전.
{
FLOAT fAngle = GetAngle();
SetAngle( fAngle + 135.0f );
m_nMoveEventCnt = 0;
m_nMoveEvent ++;
}
break;
case 2: // 1구간중 우/하로 이동
SendActMsg( OBJMSG_FORWARD );
if( ++m_nMoveEventCnt > SEC1 * 2 ) // 2초간 직진하다가 다시 좌로 90도 회전.
{
FLOAT fAngle = GetAngle();
SetAngle( fAngle - 90.0f );
m_nMoveEventCnt = 0;
m_nMoveEvent ++;
SendActMsg( OBJMSG_STOP_LOOK );
SendActMsg( OBJMSG_STOP_TURN );
SendActMsg( OBJMSG_STOP );
SetAngleX( 0 ); // 수평으로 맞춤.
}
break;
case 3: // 1구간중 3번째 구간
SendActMsg( OBJMSG_FORWARD );
if( ++m_nMoveEventCnt > SEC1 * 2 )
{
FLOAT fAngle = GetAngle();
SetAngle( fAngle - 45.0f );
m_nMoveEventCnt = 0;
m_nMoveEvent ++;
SendActMsg( OBJMSG_STOP_LOOK );
SendActMsg( OBJMSG_STOP_TURN );
SetAngleX( 0 ); // 수평으로 맞춤.
}
break;
case 4: // 2-1 구간
SendActMsg( OBJMSG_FORWARD );
if( ++m_nMoveEventCnt > SEC1 * 1 )
{
FLOAT fAngle = GetAngle();
SetAngle( fAngle - 45.0f );
m_nMoveEventCnt = 0;
m_nMoveEvent ++;
SendActMsg( OBJMSG_STOP_LOOK );
SendActMsg( OBJMSG_STOP_TURN );
SendActMsg( OBJMSG_STOP );
SetAngleX( 0 ); // 수평으로 맞춤.
}
break;
case 5: // 2-2 구간
SendActMsg( OBJMSG_FORWARD );
if( ++m_nMoveEventCnt > SEC1 * 3 )
{
FLOAT fAngle = GetAngle();
SetAngle( fAngle + 45.0f );
m_nMoveEventCnt = 0;
m_nMoveEvent = 99;
SendActMsg( OBJMSG_STOP_LOOK );
SendActMsg( OBJMSG_STOP_TURN );
SendActMsg( OBJMSG_STOP );
SetAngleX( 0 ); // 수평으로 맞춤.
}
break;
case 99:
break;
}
} // MovePattern 2
}
void CMiniMap::Draw()
{
PROFILE3("render minimap");
// The terrain isn't actually initialized until the map is loaded, which
// happens when the game is started, so abort until then.
if(!(GetGUI() && g_Game && g_Game->IsGameStarted()))
return;
CSimulation2* sim = g_Game->GetSimulation2();
CmpPtr<ICmpRangeManager> cmpRangeManager(*sim, SYSTEM_ENTITY);
ENSURE(cmpRangeManager);
// Set our globals in case they hadn't been set before
m_Camera = g_Game->GetView()->GetCamera();
m_Terrain = g_Game->GetWorld()->GetTerrain();
m_Width = (u32)(m_CachedActualSize.right - m_CachedActualSize.left);
m_Height = (u32)(m_CachedActualSize.bottom - m_CachedActualSize.top);
m_MapSize = m_Terrain->GetVerticesPerSide();
m_TextureSize = (GLsizei)round_up_to_pow2((size_t)m_MapSize);
m_MapScale = (cmpRangeManager->GetLosCircular() ? 1.f : 1.414f);
if(!m_TerrainTexture || g_GameRestarted)
CreateTextures();
// only update 2x / second
// (note: since units only move a few pixels per second on the minimap,
// we can get away with infrequent updates; this is slow)
static double last_time;
const double cur_time = timer_Time();
if(cur_time - last_time > 0.5)
{
last_time = cur_time;
if(m_TerrainDirty)
RebuildTerrainTexture();
}
glMatrixMode(GL_PROJECTION);
glPushMatrix();
glLoadIdentity();
glMatrixMode(GL_MODELVIEW);
glPushMatrix();
CMatrix3D matrix = GetDefaultGuiMatrix();
glLoadMatrixf(&matrix._11);
// Disable depth updates to prevent apparent z-fighting-related issues
// with some drivers causing units to get drawn behind the texture
glDepthMask(0);
const float x = m_CachedActualSize.left, y = m_CachedActualSize.bottom;
const float x2 = m_CachedActualSize.right, y2 = m_CachedActualSize.top;
const float z = GetBufferedZ();
const float texCoordMax = (float)(m_MapSize - 1) / (float)m_TextureSize;
const float angle = GetAngle();
// Draw the main textured quad
g_Renderer.BindTexture(0, m_TerrainTexture);
glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
DrawTexture(texCoordMax, angle, x, y, x2, y2, z);
// Draw territory boundaries
CTerritoryTexture& territoryTexture = g_Game->GetView()->GetTerritoryTexture();
territoryTexture.BindTexture(0);
glEnable(GL_BLEND);
glMatrixMode(GL_TEXTURE);
glLoadMatrixf(territoryTexture.GetMinimapTextureMatrix());
glMatrixMode(GL_MODELVIEW);
DrawTexture(1.0f, angle, x, y, x2, y2, z);
glMatrixMode(GL_TEXTURE);
glLoadIdentity();
glMatrixMode(GL_MODELVIEW);
glDisable(GL_BLEND);
// Draw the LOS quad in black, using alpha values from the LOS texture
CLOSTexture& losTexture = g_Game->GetView()->GetLOSTexture();
losTexture.BindTexture(0);
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE);
glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB_ARB, GL_REPLACE);
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_RGB_ARB, GL_PRIMARY_COLOR_ARB);
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_RGB_ARB, GL_SRC_COLOR);
glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_ALPHA_ARB, GL_REPLACE);
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_ALPHA_ARB, GL_TEXTURE);
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_ALPHA_ARB, GL_ONE_MINUS_SRC_ALPHA);
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glColor3f(0.0f, 0.0f, 0.0f);
glMatrixMode(GL_TEXTURE);
glLoadMatrixf(losTexture.GetMinimapTextureMatrix());
glMatrixMode(GL_MODELVIEW);
DrawTexture(1.0f, angle, x, y, x2, y2, z);
glMatrixMode(GL_TEXTURE);
glLoadIdentity();
glMatrixMode(GL_MODELVIEW);
glDisable(GL_BLEND);
// Set up the matrix for drawing points and lines
glPushMatrix();
glTranslatef(x, y, z);
// Rotate around the center of the map
glTranslatef((x2-x)/2.f, (y2-y)/2.f, 0.f);
// Scale square maps to fit in circular minimap area
float unitScale = (cmpRangeManager->GetLosCircular() ? 1.f : m_MapScale/2.f);
glScalef(unitScale, unitScale, 1.f);
glRotatef(angle * 180.f/M_PI, 0.f, 0.f, 1.f);
glTranslatef(-(x2-x)/2.f, -(y2-y)/2.f, 0.f);
PROFILE_START("minimap units");
// Don't enable GL_POINT_SMOOTH because it's far too slow
// (~70msec/frame on a GF4 rendering a thousand points)
glPointSize(3.f);
float sx = (float)m_Width / ((m_MapSize - 1) * TERRAIN_TILE_SIZE);
float sy = (float)m_Height / ((m_MapSize - 1) * TERRAIN_TILE_SIZE);
CSimulation2::InterfaceList ents = sim->GetEntitiesWithInterface(IID_Minimap);
std::vector<MinimapUnitVertex> vertexArray;
vertexArray.reserve(ents.size());
for (CSimulation2::InterfaceList::const_iterator it = ents.begin(); it != ents.end(); ++it)
{
MinimapUnitVertex v;
ICmpMinimap* cmpMinimap = static_cast<ICmpMinimap*>(it->second);
entity_pos_t posX, posZ;
if (cmpMinimap->GetRenderData(v.r, v.g, v.b, posX, posZ))
{
ICmpRangeManager::ELosVisibility vis = cmpRangeManager->GetLosVisibility(it->first, g_Game->GetPlayerID());
if (vis != ICmpRangeManager::VIS_HIDDEN)
{
v.a = 255;
v.x = posX.ToFloat()*sx;
v.y = -posZ.ToFloat()*sy;
vertexArray.push_back(v);
}
}
}
if (!vertexArray.empty())
{
glEnableClientState(GL_VERTEX_ARRAY);
glEnableClientState(GL_COLOR_ARRAY);
glVertexPointer(2, GL_FLOAT, sizeof(MinimapUnitVertex), &vertexArray[0].x);
glColorPointer(4, GL_UNSIGNED_BYTE, sizeof(MinimapUnitVertex), &vertexArray[0].r);
glDrawArrays(GL_POINTS, 0, (GLsizei)vertexArray.size());
glDisableClientState(GL_COLOR_ARRAY);
glDisableClientState(GL_VERTEX_ARRAY);
}
PROFILE_END("minimap units");
DrawViewRect();
glPopMatrix();
glMatrixMode(GL_PROJECTION);
glPopMatrix();
glMatrixMode(GL_MODELVIEW);
glPopMatrix();
// Reset everything back to normal
glPointSize(1.0f);
glEnable(GL_TEXTURE_2D);
glDepthMask(1);
}
/**
*
* return a vector of seed points for the given rational
*
**/
std::vector<avtVector> GetSeeds( avtPoincareIC *poincare_ic,
avtVector &point1,
avtVector &point2,
double maxDistance )
{
std::vector<avtVector> puncturePoints;
FieldlineLib fieldlib;
fieldlib.getPunctures(poincare_ic->points, avtVector(0, 1, 0), puncturePoints);
unsigned int toroidalWinding = poincare_ic->properties.toroidalWinding;
unsigned int windingGroupOffset = poincare_ic->properties.windingGroupOffset;
// Calculate angle size for each puncture point and find the one
// that forms the largest angle (i.e. flattest portion of the
// surface).
int nSeeds = 0;
double maxAngle = 0;
unsigned int best_index = 0;
unsigned int best_one_less;
unsigned int best_one_more;
bool twoPts = false;
for( int i=0; i<toroidalWinding; ++i )
{
unsigned int one_less = (i-windingGroupOffset+toroidalWinding) % toroidalWinding;
unsigned int one_more = (i+windingGroupOffset+toroidalWinding) % toroidalWinding;
if (one_less == one_more)
{
best_index = i;
best_one_more = one_more;
twoPts = true;
break;
}
if (3 <= RATIONAL_DEBUG)
cerr << "Line: "<<__LINE__<<" wgo: "<<windingGroupOffset<<", ix-1: "<<one_less<<", ix: "<<i<<", ix+1: " <<one_more<<std::endl;
avtVector pt0 = puncturePoints[one_less];
avtVector pt1 = puncturePoints[i];
avtVector pt2 = puncturePoints[one_more];
// Save the maximum angle angle and the index of the puncture point.
double angle = GetAngle( pt0, pt1, pt2 );
if (maxAngle < angle)
{
maxAngle = angle;
best_index = i;
best_one_less = one_less;
best_one_more = one_more;
}
}
// Get circle equation
avtVector pt0,pt1,pt2;
if (twoPts)
{
pt0 = puncturePoints[best_index];
pt2 = puncturePoints[best_one_more];
if (1 <= RATIONAL_DEBUG)
cerr <<"Line: "<<__LINE__<< " 2 Rational Pts:\n"
<<VectorToString(pt0)<<"\n"
<<VectorToString(pt2)<<"\n";
avtVector midpt = pt0 + 0.5 * (pt2-pt0);
avtVector cx = (pt2-pt0).cross(avtVector(0,1,0));
avtVector newpt = midpt + .5*cx;
if (1 <= RATIONAL_DEBUG)
cerr <<"Line: "<<__LINE__<< " 2 New Pts:\n"
<<VectorToString(midpt)<<"\n"
<<VectorToString(newpt)<<"\n";
pt1 = newpt;
}
else
{
// Find the circle that intersects the three punctures points which
// approximates the cross section of the surface.
// Get circle equation
pt0 = puncturePoints[best_one_less];
pt1 = puncturePoints[best_index];
pt2 = puncturePoints[best_one_more];
if (1 <= RATIONAL_DEBUG)
cerr <<"Line: "<<__LINE__<< " Rational Pts:\n"
<<VectorToString(pt0)<<"\n"
<<VectorToString(pt1)<<"\n"
<<VectorToString(pt2)<<"\n";
}
point1 = pt1; //for future reference
point2 = pt2;
if (1 <= RATIONAL_DEBUG)
cerr <<"Line: "<<__LINE__<< " New seeds between:\n"
<<VectorToString(point1)<<"\n"
<<VectorToString(point2)<<"\n";
// Center of the circle
/////*********** Find The Circle Using Three Points******************///
double ax,ay,bx,by,cx,cy,x1,y11,dx1,dy1,x2,y2,dx2,dy2,ox,oy,dx,dy,radius;
ax = pt0[0]; ay = pt0[2];
bx = pt1[0]; by = pt1[2];
cx = pt2[0]; cy = pt2[2];
x1 = (bx + ax) / 2;
y11 = (by + ay) / 2;
dy1 = bx - ax;
dx1 = -(by - ay);
x2 = (cx + bx) / 2;
y2 = (cy + by) / 2;
dy2 = cx - bx;
dx2 = -(cy - by);
ox = (y11 * dx1 * dx2 + x2 * dx1 * dy2 - x1 * dy1 * dx2 - y2 * dx1 * dx2)/ (dx1 * dy2 - dy1 * dx2);
oy = (ox - x1) * dy1 / dx1 + y11;
dx = ox - ax;
dy = oy - ay;
radius = sqrt(dx * dx + dy * dy);
avtVector center(ox,0,oy);
// Get the number of points needed to cover the range between the two
// the puncture points.
double dist = (pt2 - pt1).length();
nSeeds = dist / maxDistance;
if( dist > (double) nSeeds * maxDistance )
++nSeeds;
double angle =GetAngle(point1, center, point2);
// Add seeds stretching between two of the puncture points.
std::vector<avtVector> seedPts;
seedPts.resize( nSeeds );
if (1 <= RATIONAL_DEBUG)
std::cerr <<"Line: "<<__LINE__
<< " \ncenter: " << center
<< " \nradius: " << radius
<< " \nnSeeds: " << nSeeds
<< " \nAngle: " << angle
<< std::endl;
for( double i=0; i<nSeeds; ++i)
{
double t = i / nSeeds;
avtVector X = center + (std::sin((1-t) * angle ) * (point1-center) + std::sin(t * angle) * (point2-center)) / std::sin(angle);
X[1] = Z_OFFSET;
seedPts[i] = X;
if (3 <= RATIONAL_DEBUG)
cerr << "New Seed: "<<VectorToString(X) << std::endl;
}
return seedPts;
}
void CPlayers::RenderHook(
const CNetObj_Character *pPrevChar,
const CNetObj_Character *pPlayerChar,
const CNetObj_PlayerInfo *pPrevInfo,
const CNetObj_PlayerInfo *pPlayerInfo
)
{
CNetObj_Character Prev;
CNetObj_Character Player;
Prev = *pPrevChar;
Player = *pPlayerChar;
CNetObj_PlayerInfo pInfo = *pPlayerInfo;
CTeeRenderInfo RenderInfo = m_pClient->m_aClients[pInfo.m_ClientId].m_RenderInfo;
// check for teamplay modes
bool IsTeamplay = false;
if(m_pClient->m_Snap.m_pGameobj)
IsTeamplay = (m_pClient->m_Snap.m_pGameobj->m_Flags&GAMEFLAG_TEAMS) != 0;
// check for ninja
if (Player.m_Weapon == WEAPON_NINJA)
{
// change the skin for the player to the ninja
int Skin = m_pClient->m_pSkins->Find("x_ninja");
if(Skin != -1)
{
if(IsTeamplay)
RenderInfo.m_Texture = m_pClient->m_pSkins->Get(Skin)->m_ColorTexture;
else
{
RenderInfo.m_Texture = m_pClient->m_pSkins->Get(Skin)->m_OrgTexture;
RenderInfo.m_ColorBody = vec4(1,1,1,1);
RenderInfo.m_ColorFeet = vec4(1,1,1,1);
}
}
}
float IntraTick = Client()->IntraGameTick();
if(Player.m_Health < 0) // dont render dead players
return;
// set size
RenderInfo.m_Size = 64.0f;
// use preditect players if needed
if(pInfo.m_Local && g_Config.m_ClPredict && Client()->State() != IClient::STATE_DEMOPLAYBACK)
{
if(!m_pClient->m_Snap.m_pLocalCharacter || (m_pClient->m_Snap.m_pLocalCharacter->m_Health < 0) || (m_pClient->m_Snap.m_pGameobj && m_pClient->m_Snap.m_pGameobj->m_GameOver))
{
}
else
{
// apply predicted results
m_pClient->m_PredictedChar.Write(&Player);
m_pClient->m_PredictedPrevChar.Write(&Prev);
IntraTick = Client()->PredIntraGameTick();
}
}
vec2 Position = mix(vec2(Prev.m_X, Prev.m_Y), vec2(Player.m_X, Player.m_Y), IntraTick);
if(Prev.m_Health < 0) // Don't flicker from previous position
Position = vec2(Player.m_X, Player.m_Y);
// draw hook
if (Prev.m_HookState>0 && Player.m_HookState>0)
{
Graphics()->TextureSet(g_pData->m_aImages[IMAGE_GAME].m_Id);
Graphics()->QuadsBegin();
//Graphics()->QuadsBegin();
vec2 Pos = Position;
vec2 HookPos;
if(pPlayerChar->m_HookedPlayer != -1)
{
if(m_pClient->m_Snap.m_pLocalInfo && pPlayerChar->m_HookedPlayer == m_pClient->m_Snap.m_pLocalInfo->m_ClientId)
{
if(Client()->State() == IClient::STATE_DEMOPLAYBACK) // only use prediction if needed
HookPos = vec2(m_pClient->m_LocalCharacterPos.x, m_pClient->m_LocalCharacterPos.y);
else
HookPos = mix(vec2(m_pClient->m_PredictedPrevChar.m_Pos.x, m_pClient->m_PredictedPrevChar.m_Pos.y),
vec2(m_pClient->m_PredictedChar.m_Pos.x, m_pClient->m_PredictedChar.m_Pos.y), Client()->PredIntraGameTick());
}
else
HookPos = mix(vec2(pPrevChar->m_HookX, pPrevChar->m_HookY), vec2(pPlayerChar->m_HookX, pPlayerChar->m_HookY), Client()->IntraGameTick());
}
else
HookPos = mix(vec2(Prev.m_HookX, Prev.m_HookY), vec2(Player.m_HookX, Player.m_HookY), IntraTick);
float d = distance(Pos, HookPos);
vec2 Dir = normalize(Pos-HookPos);
Graphics()->QuadsSetRotation(GetAngle(Dir)+pi);
// render head
RenderTools()->SelectSprite(SPRITE_HOOK_HEAD);
IGraphics::CQuadItem QuadItem(HookPos.x, HookPos.y, 24,16);
Graphics()->QuadsDraw(&QuadItem, 1);
// render chain
RenderTools()->SelectSprite(SPRITE_HOOK_CHAIN);
IGraphics::CQuadItem Array[1024];
int i = 0;
for(float f = 24; f < d && i < 1024; f += 24, i++)
{
vec2 p = HookPos + Dir*f;
Array[i] = IGraphics::CQuadItem(p.x, p.y,24,16);
}
Graphics()->QuadsDraw(Array, i);
Graphics()->QuadsSetRotation(0);
Graphics()->QuadsEnd();
RenderHand(&RenderInfo, Position, normalize(HookPos-Pos), -pi/2, vec2(20, 0));
}
}
long CArc::HitTest(long x, long y)
{
if(m_locked){
return TK_NONE;
}
if(m_lStatus!=ST_NOMAL) return TK_NONE;
CRect rtTemp;
POINT pt;
pt.x=x;
pt.y=y;
rtTemp.SetRect(m_lx1-DELTA,m_ly1-DELTA,m_lx1+DELTA,m_ly1+DELTA);
if(rtTemp.PtInRect(pt)) return TK_LT;
rtTemp.SetRect(m_lx1-DELTA,m_ly2-DELTA,m_lx1+DELTA,m_ly2+DELTA);
if(rtTemp.PtInRect(pt)) return TK_LB;
rtTemp.SetRect(m_lx2-DELTA,m_ly1-DELTA,m_lx2+DELTA,m_ly1+DELTA);
if(rtTemp.PtInRect(pt)) return TK_RT;
rtTemp.SetRect(m_lx2-DELTA,m_ly2-DELTA,m_lx2+DELTA,m_ly2+DELTA);
if(rtTemp.PtInRect(pt)) return TK_RB;
rtTemp.SetRect((m_lx1+m_lx2)/2-DELTA,m_ly1-DELTA,(m_lx1+m_lx2)/2+DELTA,m_ly1+DELTA);
if(rtTemp.PtInRect(pt)) return TK_TM;
rtTemp.SetRect((m_lx1+m_lx2)/2-DELTA,m_ly2-DELTA,(m_lx1+m_lx2)/2+DELTA,m_ly2+DELTA);
if(rtTemp.PtInRect(pt)) return TK_BM;
rtTemp.SetRect(m_lx1-DELTA,(m_ly1+m_ly2)/2-DELTA,m_lx1+DELTA,(m_ly1+m_ly2)/2+DELTA);
if(rtTemp.PtInRect(pt)) return TK_LM;
rtTemp.SetRect(m_lx2-DELTA,(m_ly1+m_ly2)/2-DELTA,m_lx2+DELTA,(m_ly1+m_ly2)/2+DELTA);
if(rtTemp.PtInRect(pt)) return TK_RM;
rtTemp.SetRect(m_lx3-DELTA,m_ly3-DELTA,m_lx3+DELTA,m_ly3+DELTA);
if(rtTemp.PtInRect(pt)) return TK_SP;
rtTemp.SetRect(m_lx4-DELTA,m_ly4-DELTA,m_lx4+DELTA,m_ly4+DELTA);
if(rtTemp.PtInRect(pt)) return TK_EP;
long x1,y1,x2,y2;
if(m_lx1<=m_lx2){
x1=m_lx1;
x2=m_lx2;
}else{
x1=m_lx2;
x2=m_lx1;
}
if(m_ly1<m_ly2){
y1=m_ly1;
y2=m_ly2;
}else{
y1=m_ly2;
y2=m_ly1;
}
CRgn rgnTmp;
if(rgnTmp.CreateEllipticRgn(x1-DELTA,y1-DELTA,x2+DELTA,y2+DELTA)){
if(!rgnTmp.PtInRegion(pt)) return TK_NONE;
x1=x1+DELTA;
y1=y1+DELTA;
x2=x2-DELTA;
y2=y2-DELTA;
if(x1<x2 && y1<y2){
CRgn rgnTmp;
if(rgnTmp.CreateEllipticRgn(x1,y1,x2,y2)){
if(rgnTmp.PtInRegion(pt)) return TK_NONE;
}else{
return TK_NONE;
}
}
double dx=(double)x-((double)m_lx1+(double)m_lx2)/2;
double dy=-(double)y+((double)m_ly1+(double)m_ly2)/2;
double dxs=(double)m_lx3-((double)m_lx1+(double)m_lx2)/2;
double dys=-(double)m_ly3+((double)m_ly1+(double)m_ly2)/2;
double dxe=(double)m_lx4-((double)m_lx1+(double)m_lx2)/2;
double dye=-(double)m_ly4+((double)m_ly1+(double)m_ly2)/2;
double sa=GetAngle(dxs,dys);
double ea=GetAngle(dxe,dye);
double pa=GetAngle(dx,dy);
if(SPE(sa,pa,ea)) return TK_MOV;
}
return TK_NONE;
}
void AreaTrigger::UpdateSplinePosition(uint32 diff)
{
if (_reachedDestination)
return;
if (!HasSplines())
return;
_movementTime += diff;
if (_movementTime >= GetTimeToTarget())
{
_reachedDestination = true;
_lastSplineIndex = int32(_spline->last());
G3D::Vector3 lastSplinePosition = _spline->getPoint(_lastSplineIndex);
GetMap()->AreaTriggerRelocation(this, lastSplinePosition.x, lastSplinePosition.y, lastSplinePosition.z, GetOrientation());
#ifdef TRINITY_DEBUG
DebugVisualizePosition();
#endif
_ai->OnSplineIndexReached(_lastSplineIndex);
_ai->OnDestinationReached();
return;
}
float currentTimePercent = float(_movementTime) / float(GetTimeToTarget());
if (currentTimePercent <= 0.f)
return;
if (GetMiscTemplate()->MoveCurveId)
{
float progress = sDB2Manager.GetCurveValueAt(GetMiscTemplate()->MoveCurveId, currentTimePercent);
if (progress < 0.f || progress > 1.f)
{
TC_LOG_ERROR("entities.areatrigger", "AreaTrigger (Id: %u, SpellMiscId: %u) has wrong progress (%f) caused by curve calculation (MoveCurveId: %u)",
GetTemplate()->Id, GetMiscTemplate()->MiscId, progress, GetMiscTemplate()->MorphCurveId);
}
else
currentTimePercent = progress;
}
int lastPositionIndex = 0;
float percentFromLastPoint = 0;
_spline->computeIndex(currentTimePercent, lastPositionIndex, percentFromLastPoint);
G3D::Vector3 currentPosition;
_spline->evaluate_percent(lastPositionIndex, percentFromLastPoint, currentPosition);
float orientation = GetOrientation();
if (GetTemplate()->HasFlag(AREATRIGGER_FLAG_HAS_FACE_MOVEMENT_DIR))
{
G3D::Vector3 const& nextPoint = _spline->getPoint(lastPositionIndex + 1);
orientation = GetAngle(nextPoint.x, nextPoint.y);
}
GetMap()->AreaTriggerRelocation(this, currentPosition.x, currentPosition.y, currentPosition.z, orientation);
#ifdef TRINITY_DEBUG
DebugVisualizePosition();
#endif
if (_lastSplineIndex != lastPositionIndex)
{
_lastSplineIndex = lastPositionIndex;
_ai->OnSplineIndexReached(_lastSplineIndex);
}
}
bool CArc::RInR(LPCRECT lpRect)
{
if(m_locked){
return false;
}
if(m_lStatus!=ST_NOMAL) return false;
/*
double ca=((double)m_lx1+(double)m_lx2)/2.;
double cb=((double)m_ly1+(double)m_ly2)/2.;
double ra=((double)m_lx2-(double)m_lx1)/2.;
double rb=((double)m_ly2-(double)m_ly1)/2.;
double dxs=(double)m_lx3-ca;
double dys=-(double)m_ly3+cb;
double dxe=(double)m_lx4-ca;
double dye=-(double)m_ly4+cb;
double sa=GetAngle(dxs,dys);
double ea=GetAngle(dxe,dye);
double pa;
CRect recTmp(lpRect->left-1,lpRect->top-1,lpRect->right+1,lpRect->bottom+1);
POINT pt;
pt.x=ca+ra*cos(sa);
pt.y=cb-rb*sin(sa);
if(recTmp.PtInRect(pt)) return true;
pt.x=ca+ra*cos(ea);
pt.y=cb-rb*sin(ea);
if(recTmp.PtInRect(pt)) return true;
double dxp,dyp;
dxp=(double)(lpRect->left)-ca;
if(fabs(dxp)<ra){
dyp=rb*sqrt(1.-dxp*dxp/ra/ra);
pa=GetAngle(dxp,dyp);
pt.x=lpRect->left;
if(SPE(sa,pa,ea)){
pt.y=(long)cb-(long)dyp;
if(recTmp.PtInRect(pt)) return true;
}
pa=GetAngle(dxp,-dyp);
if(SPE(sa,pa,ea)){
pt.y=(long)cb+(long)dyp;
if(recTmp.PtInRect(pt)) return true;
}
}
dxp=(double)(lpRect->right)-ca;
if(fabs(dxp)<ra){
dyp=rb*sqrt(1.-dxp*dxp/ra/ra);
pa=GetAngle(dxp,dyp);
pt.x=lpRect->right;
if(SPE(sa,pa,ea)){
pt.y=(long)cb-(long)dyp;
if(recTmp.PtInRect(pt)) return true;
}
pa=GetAngle(dxp,-dyp);
if(SPE(sa,pa,ea)){
pt.y=(long)cb+(long)dyp;
if(recTmp.PtInRect(pt)) return true;
}
}
dyp=-(double)(lpRect->top)+cb;
if(fabs(dyp)<rb){
dxp=ra*sqrt(1.-dyp*dyp/rb/rb);
pa=GetAngle(dxp,dyp);
pt.y=lpRect->top;
if(SPE(sa,pa,ea)){
pt.x=(long)ca+(long)dxp;
if(recTmp.PtInRect(pt)) return true;
}
pa=GetAngle(-dxp,dyp);
if(SPE(sa,pa,ea)){
pt.x=(long)ca-(long)dxp;
if(recTmp.PtInRect(pt)) return true;
}
}
dyp=-(double)(lpRect->bottom)+cb;
if(fabs(dyp)<rb){
dxp=ra*sqrt(1.-dyp*dyp/rb/rb);
pa=GetAngle(dxp,dyp);
pt.y=lpRect->bottom;
if(SPE(sa,pa,ea)){
pt.x=(long)ca+(long)dxp;
if(recTmp.PtInRect(pt)) return true;
}
pa=GetAngle(-dxp,dyp);
if(SPE(sa,pa,ea)){
pt.x=(long)ca-(long)dxp;
if(recTmp.PtInRect(pt)) return true;
}
}
*/
// 原来的相交选取改为现在的包含选取，对于圆弧曲线，
// 如果包含曲线两头的两个点，选取
double ca=((double)m_lx1+(double)m_lx2)/2.;
double cb=((double)m_ly1+(double)m_ly2)/2.;
double ra=((double)m_lx2-(double)m_lx1)/2.;
double rb=((double)m_ly2-(double)m_ly1)/2.;
double dxs=(double)m_lx3-ca;
double dys=-(double)m_ly3+cb;
double dxe=(double)m_lx4-ca;
double dye=-(double)m_ly4+cb;
double sa=GetAngle(dxs,dys);
double ea=GetAngle(dxe,dye);
CRect rectTmp(lpRect->left-1,lpRect->top-1,lpRect->right+1,lpRect->bottom+1);
rectTmp.NormalizeRect();
POINT pt1, pt2;
pt1.x=ca+ra*cos(sa);
pt1.y=cb-rb*sin(sa);
pt2.x=ca+ra*cos(ea);
pt2.y=cb-rb*sin(ea);
if(rectTmp.PtInRect(pt1) && rectTmp.PtInRect(pt2)){
return true;
}else{
return false;
}
}
void Shooter::Log() {
SmartDashboard::PutBoolean("Shooter Initialized", IsInitialized());
LogAngle(GetAngle());
LogSpeed(GetFWSpeed());
}
// ハイパーアーツ
bool Thief::HyperArts(void)
{
//空中で発動しても停止する
move = Vector3(0, -GRAVITY, 0);
if ( !initflag )
{
sound->PlaySE( SE::HYPER_ATTACK );
sound->PlaySE( SE::KAITO_HYPER );
initflag = true;
}
attackInfo.power = OFFENSIVE_POWER::HYPER;
attackInfo.dropPower = DROP_POWER::HYPER;
attackInfo.coinDropType = DROP_TYPE::SUCTION;
SetParameterState(PARAMETER_STATE::UNRIVALED);
move = Vector3(0, 0 - GRAVITY, 0); //撃ってる間は静止させる
SetMotion(THIEF::MOTION_DATA::HYPERARTS);
// 行列から情報取得
Vector3 front = GetFront();
Vector3 right = GetRight();
Vector3 p_pos = GetPos();
SetMove(Vector3(0.0f, move.y, 0.0f));
if (obj->GetFrame() >= THIEF::MOTION_FRAME::HYPERARTS_ATTACKSTART/* && obj->GetFrame() < THIEF::MOTION_FRAME::HYPERARTS_ATTACKEND*/)
{
float t = GetBezier(ePrm_t::eRapid_Lv5, ePrm_t::eSlow_Lv1, attackInfo.t);
Vector3 f = front * (2.0f * sinf(D3DX_PI * t));
Vector3 r = -right * (2.0f * cosf(D3DX_PI * t));
attackInfo.bottom = p_pos + f + r;
switch (HyperStep)
{
case 0:
// あたり判定のパラメータを与える
attackInfo.top = attackInfo.bottom + r * HyperRate;
attackInfo.r = 2.5f;
HyperRate += 1.0;
if (HyperRate > 20.0f) HyperStep++;
break;
case 1:
// パラメータ加算
attackInfo.top = attackInfo.bottom + f * HyperRate + r * HyperRate;
attackInfo.t += 0.03f;
if (attackInfo.t >= 1.0f)
{
HyperStep++;
}
break;
case 2:
//attackInfo.top = attackInfo.bottom + r * rate;
attackInfo.t = 0.0f;
HyperRate -= 1.0f;
break;
}
armRenderflag = true;
}
Vector3 v1, v2;
v1 = front;
v2 = attackInfo.top - attackInfo.bottom;
v1.Normalize();
v2.Normalize();
float armAngle = GetAngle(v1, v2);
Vector3 cross;
Vector3Cross(cross, v1, v2);
if (cross.y < 0) armAngle = -armAngle;
arm->SetPos(pos);
arm->SetAngle(angle.y + armAngle);
arm->SetScale(Vector3(0.03f, 0.03f, HyperRate * 0.01f));
arm->Update();
if (HyperRate < 0)
{
HyperStep = 0;
HyperRate = 0;
armRenderflag = false;
initflag = false;
return true;
}
return false;
}
void CCharacter::FireWeapon()
{
if(m_ReloadTimer != 0)
return;
DoWeaponSwitch();
vec2 Direction = normalize(vec2(m_LatestInput.m_TargetX, m_LatestInput.m_TargetY));
bool FullAuto = false;
if(m_ActiveWeapon == WEAPON_GRENADE || m_ActiveWeapon == WEAPON_SHOTGUN || m_ActiveWeapon == WEAPON_LASER)
FullAuto = true;
// check if we gonna fire
bool WillFire = false;
if(CountInput(m_LatestPrevInput.m_Fire, m_LatestInput.m_Fire).m_Presses)
WillFire = true;
if(FullAuto && (m_LatestInput.m_Fire&1) && m_aWeapons[m_ActiveWeapon].m_Ammo)
WillFire = true;
if(!WillFire)
return;
// check for ammo
if(!m_aWeapons[m_ActiveWeapon].m_Ammo)
{
// 125ms is a magical limit of how fast a human can click
m_ReloadTimer = 125 * Server()->TickSpeed() / 1000;
GameServer()->CreateSound(m_Pos, SOUND_WEAPON_NOAMMO);
return;
}
vec2 ProjStartPos = m_Pos+Direction*m_ProximityRadius*0.75f;
switch(m_ActiveWeapon)
{
case WEAPON_HAMMER:
{
// reset objects Hit
m_NumObjectsHit = 0;
GameServer()->CreateSound(m_Pos, SOUND_HAMMER_FIRE);
CCharacter *apEnts[MAX_CLIENTS];
int Hits = 0;
int Num = GameServer()->m_World.FindEntities(ProjStartPos, m_ProximityRadius*0.5f, (CEntity**)apEnts,
MAX_CLIENTS, CGameWorld::ENTTYPE_CHARACTER);
for (int i = 0; i < Num; ++i)
{
CCharacter *pTarget = apEnts[i];
if ((pTarget == this) || GameServer()->Collision()->IntersectLine(ProjStartPos, pTarget->m_Pos, NULL, NULL))
continue;
// set his velocity to fast upward (for now)
if(length(pTarget->m_Pos-ProjStartPos) > 0.0f)
GameServer()->CreateHammerHit(pTarget->m_Pos-normalize(pTarget->m_Pos-ProjStartPos)*m_ProximityRadius*0.5f);
else
GameServer()->CreateHammerHit(ProjStartPos);
vec2 Dir;
if (length(pTarget->m_Pos - m_Pos) > 0.0f)
Dir = normalize(pTarget->m_Pos - m_Pos);
else
Dir = vec2(0.f, -1.f);
pTarget->TakeDamage(vec2(0.f, -1.f) + normalize(Dir + vec2(0.f, -1.1f)) * 10.0f, g_pData->m_Weapons.m_Hammer.m_pBase->m_Damage,
m_pPlayer->GetCID(), m_ActiveWeapon);
Hits++;
}
// if we Hit anything, we have to wait for the reload
if(Hits)
m_ReloadTimer = Server()->TickSpeed()/3;
} break;
case WEAPON_GUN:
{
CProjectile *pProj = new CProjectile(GameWorld(), WEAPON_GUN,
m_pPlayer->GetCID(),
ProjStartPos,
Direction,
(int)(Server()->TickSpeed()*GameServer()->Tuning()->m_GunLifetime),
1, 0, 0, -1, WEAPON_GUN);
// pack the Projectile and send it to the client Directly
CNetObj_Projectile p;
pProj->FillInfo(&p);
CMsgPacker Msg(NETMSGTYPE_SV_EXTRAPROJECTILE);
Msg.AddInt(1);
for(unsigned i = 0; i < sizeof(CNetObj_Projectile)/sizeof(int); i++)
Msg.AddInt(((int *)&p)[i]);
Server()->SendMsg(&Msg, 0, m_pPlayer->GetCID());
GameServer()->CreateSound(m_Pos, SOUND_GUN_FIRE);
} break;
case WEAPON_SHOTGUN:
{
int ShotSpread = 2;
CMsgPacker Msg(NETMSGTYPE_SV_EXTRAPROJECTILE);
Msg.AddInt(ShotSpread*2+1);
for(int i = -ShotSpread; i <= ShotSpread; ++i)
{
float Spreading[] = {-0.185f, -0.070f, 0, 0.070f, 0.185f};
float a = GetAngle(Direction);
a += Spreading[i+2];
float v = 1-(absolute(i)/(float)ShotSpread);
float Speed = mix((float)GameServer()->Tuning()->m_ShotgunSpeeddiff, 1.0f, v);
CProjectile *pProj = new CProjectile(GameWorld(), WEAPON_SHOTGUN,
m_pPlayer->GetCID(),
ProjStartPos,
vec2(cosf(a), sinf(a))*Speed,
(int)(Server()->TickSpeed()*GameServer()->Tuning()->m_ShotgunLifetime),
1, 0, 0, -1, WEAPON_SHOTGUN);
// pack the Projectile and send it to the client Directly
CNetObj_Projectile p;
pProj->FillInfo(&p);
for(unsigned i = 0; i < sizeof(CNetObj_Projectile)/sizeof(int); i++)
Msg.AddInt(((int *)&p)[i]);
}
Server()->SendMsg(&Msg, 0,m_pPlayer->GetCID());
GameServer()->CreateSound(m_Pos, SOUND_SHOTGUN_FIRE);
} break;
case WEAPON_GRENADE:
{
CProjectile *pProj = new CProjectile(GameWorld(), WEAPON_GRENADE,
m_pPlayer->GetCID(),
ProjStartPos,
Direction,
(int)(Server()->TickSpeed()*GameServer()->Tuning()->m_GrenadeLifetime),
1, true, 0, SOUND_GRENADE_EXPLODE, WEAPON_GRENADE);
// pack the Projectile and send it to the client Directly
CNetObj_Projectile p;
pProj->FillInfo(&p);
CMsgPacker Msg(NETMSGTYPE_SV_EXTRAPROJECTILE);
Msg.AddInt(1);
for(unsigned i = 0; i < sizeof(CNetObj_Projectile)/sizeof(int); i++)
Msg.AddInt(((int *)&p)[i]);
Server()->SendMsg(&Msg, 0, m_pPlayer->GetCID());
GameServer()->CreateSound(m_Pos, SOUND_GRENADE_FIRE);
} break;
case WEAPON_LASER:
{
new CLaser(GameWorld(), m_Pos, Direction, GameServer()->Tuning()->m_LaserReach, m_pPlayer->GetCID());
GameServer()->CreateSound(m_Pos, SOUND_LASER_FIRE);
} break;
case WEAPON_NINJA:
{
// reset Hit objects
m_NumObjectsHit = 0;
m_Ninja.m_ActivationDir = Direction;
m_Ninja.m_CurrentMoveTime = g_pData->m_Weapons.m_Ninja.m_Movetime * Server()->TickSpeed() / 1000;
m_Ninja.m_OldVelAmount = length(m_Core.m_Vel);
GameServer()->CreateSound(m_Pos, SOUND_NINJA_FIRE);
} break;
}
m_AttackTick = Server()->Tick();
if(m_aWeapons[m_ActiveWeapon].m_Ammo > 0) // -1 == unlimited
m_aWeapons[m_ActiveWeapon].m_Ammo--;
if(!m_ReloadTimer)
m_ReloadTimer = g_pData->m_Weapons.m_aId[m_ActiveWeapon].m_Firedelay * Server()->TickSpeed() / 1000;
}
void CItems::RenderProjectile(const CNetObj_Projectile *pCurrent, int ItemID)
{
// get positions
float Curvature = 0;
float Speed = 0;
if(pCurrent->m_Type == WEAPON_GRENADE)
{
Curvature = m_pClient->m_Tuning.m_GrenadeCurvature;
Speed = m_pClient->m_Tuning.m_GrenadeSpeed;
}
else if(pCurrent->m_Type == WEAPON_SHOTGUN)
{
Curvature = m_pClient->m_Tuning.m_ShotgunCurvature;
Speed = m_pClient->m_Tuning.m_ShotgunSpeed;
}
else if(pCurrent->m_Type == WEAPON_GUN)
{
Curvature = m_pClient->m_Tuning.m_GunCurvature;
Speed = m_pClient->m_Tuning.m_GunSpeed;
}
static float s_LastGameTickTime = Client()->GameTickTime();
if(m_pClient->m_Snap.m_pGameInfoObj && !(m_pClient->m_Snap.m_pGameInfoObj->m_GameStateFlags&GAMESTATEFLAG_PAUSED))
s_LastGameTickTime = Client()->GameTickTime();
float Ct = (Client()->PrevGameTick()-pCurrent->m_StartTick)/(float)SERVER_TICK_SPEED + s_LastGameTickTime;
if(Ct < 0)
return; // projectile havn't been shot yet
vec2 StartPos(pCurrent->m_X, pCurrent->m_Y);
vec2 StartVel(pCurrent->m_VelX/100.0f, pCurrent->m_VelY/100.0f);
vec2 Pos = CalcPos(StartPos, StartVel, Curvature, Speed, Ct);
vec2 PrevPos = CalcPos(StartPos, StartVel, Curvature, Speed, Ct-0.001f);
Graphics()->TextureSet(g_pData->m_aImages[IMAGE_GAME].m_Id);
Graphics()->QuadsBegin();
RenderTools()->SelectSprite(g_pData->m_Weapons.m_aId[clamp(pCurrent->m_Type, 0, NUM_WEAPONS-1)].m_pSpriteProj);
vec2 Vel = Pos-PrevPos;
//vec2 pos = mix(vec2(prev->x, prev->y), vec2(current->x, current->y), Client()->IntraGameTick());
// add particle for this projectile
if(pCurrent->m_Type == WEAPON_GRENADE)
{
m_pClient->m_pEffects->SmokeTrail(Pos, Vel*-1);
static float s_Time = 0.0f;
static float s_LastLocalTime = Client()->LocalTime();
if(Client()->State() == IClient::STATE_DEMOPLAYBACK)
{
const IDemoPlayer::CInfo *pInfo = DemoPlayer()->BaseInfo();
if(!pInfo->m_Paused)
s_Time += (Client()->LocalTime()-s_LastLocalTime)*pInfo->m_Speed;
}
else
{
if(m_pClient->m_Snap.m_pGameInfoObj && !(m_pClient->m_Snap.m_pGameInfoObj->m_GameStateFlags&GAMESTATEFLAG_PAUSED))
s_Time += Client()->LocalTime()-s_LastLocalTime;
}
Graphics()->QuadsSetRotation(s_Time*pi*2*2 + ItemID);
s_LastLocalTime = Client()->LocalTime();
}
else
{
m_pClient->m_pEffects->BulletTrail(Pos);
if(length(Vel) > 0.00001f)
Graphics()->QuadsSetRotation(GetAngle(Vel));
else
Graphics()->QuadsSetRotation(0);
}
IGraphics::CQuadItem QuadItem(Pos.x, Pos.y, 32, 32);
Graphics()->QuadsDraw(&QuadItem, 1);
Graphics()->QuadsSetRotation(0);
Graphics()->QuadsEnd();
}
//---------------------------------------------------------------------
float CControlTarget::Render(LPDIRECT3DDEVICE7 m_pd3dDevice)
{
int i = 0;
SETCULL(m_pd3dDevice, D3DCULL_NONE);
SETZWRITE(m_pd3dDevice, FALSE);
SETALPHABLEND(m_pd3dDevice, TRUE);
//----------------------------
m_pd3dDevice->SetRenderState(D3DRENDERSTATE_SRCBLEND, D3DBLEND_ONE);
m_pd3dDevice->SetRenderState(D3DRENDERSTATE_DESTBLEND, D3DBLEND_ONE);
SETALPHABLEND(m_pd3dDevice, TRUE);
if (tex_mm && tex_mm->m_pddsSurface)
{
SETTC(m_pd3dDevice, tex_mm);
}
// -------------------
fTrail += 1;
if (fTrail >= 300) fTrail = 0;
int n = BEZIERPrecision;
float delta = 1.0f / n;
fTrail = (ulCurrentTime * fOneOnDuration) * 9 * (n + 2);
EERIE_3D lastpos, newpos;
EERIE_3D v;
int arx_check_init = -1;
newpos.x = 0;
newpos.y = 0;
newpos.z = 0;
lastpos.x = pathways[0].sx;
lastpos.y = pathways[0].sy;
lastpos.z = pathways[0].sz;
for (i = 0; i < 9; i++)
{
int kp = i;
int kpprec = (i > 0) ? kp - 1 : kp ;
int kpsuiv = kp + 1 ;
int kpsuivsuiv = (i < (9 - 2)) ? kpsuiv + 1 : kpsuiv;
for (int toto = 1; toto < n; toto++)
{
if (fTrail < i * n + toto) break;
float t = toto * delta;
float t1 = t;
float t2 = t1 * t1 ;
float t3 = t2 * t1 ;
float f0 = 2.f * t3 - 3.f * t2 + 1.f ;
float f1 = -2.f * t3 + 3.f * t2 ;
float f2 = t3 - 2.f * t2 + t1 ;
float f3 = t3 - t2 ;
float val = pathways[kpsuiv].sx;
float p0 = 0.5f * (val - pathways[kpprec].sx) ;
float p1 = 0.5f * (pathways[kpsuivsuiv].sx - pathways[kp].sx) ;
v.x = f0 * pathways[kp].sx + f1 * val + f2 * p0 + f3 * p1 ;
val = pathways[kpsuiv].sy ;
p0 = 0.5f * (val - pathways[kpprec].sy) ;
p1 = 0.5f * (pathways[kpsuivsuiv].sy - pathways[kp].sy) ;
v.y = f0 * pathways[kp].sy + f1 * val + f2 * p0 + f3 * p1 ;
val = pathways[kpsuiv].sz ;
p0 = 0.5f * (val - pathways[kpprec].sz) ;
p1 = 0.5f * (pathways[kpsuivsuiv].sz - pathways[kp].sz) ;
v.z = f0 * pathways[kp].sz + f1 * val + f2 * p0 + f3 * p1 ;
newpos.x = v.x;
newpos.y = v.y;
newpos.z = v.z;
if (!((fTrail - (i * n + toto)) > 70))
{
float c = 1.0f - ((fTrail - (i * n + toto)) / 70.0f);
int j = ARX_PARTICLES_GetFree();
if ((j != -1) && (!ARXPausedTimer))
{
ParticleCount++;
particle[j].exist = 1;
particle[j].zdec = 0;
particle[j].ov.x = lastpos.x;
particle[j].ov.y = lastpos.y;
particle[j].ov.z = lastpos.z;
particle[j].move.x = 0;
particle[j].move.y = 0;
particle[j].move.z = 0;
particle[j].siz = 5 * c;
particle[j].tolive = 10 + (unsigned long)(float)(rnd() * 100.f);
particle[j].scale.x = 1;
particle[j].scale.y = 1;
particle[j].scale.z = 1;
particle[j].timcreation = lARXTime;
particle[j].tc = tex_mm;
particle[j].special = FADE_IN_AND_OUT | ROTATING | MODULATE_ROTATION | DISSIPATING;
particle[j].fparam = 0.0000001f;
particle[j].r = c;
particle[j].g = c;
particle[j].b = c;
}
}
float nx = lastpos.x;
float ny = lastpos.y;
float nz = lastpos.z;
lastpos.x = newpos.x;
lastpos.y = newpos.y;
lastpos.z = newpos.z;
newpos.x = nx;
newpos.y = ny;
newpos.z = nz;
++arx_check_init;
int j = ARX_PARTICLES_GetFree();
if ((j != -1) && (!ARXPausedTimer))
{
ParticleCount++;
particle[j].exist = 1;
particle[j].zdec = 0;
particle[j].ov.x = lastpos.x;
particle[j].ov.y = lastpos.y;
particle[j].ov.z = lastpos.z;
particle[j].move.x = 0;
particle[j].move.y = 0;
particle[j].move.z = 0;
particle[j].siz = 5;
particle[j].tolive = 10 + (unsigned long)(float)(rnd() * 100.f);
particle[j].scale.x = 1;
particle[j].scale.y = 1;
particle[j].scale.z = 1;
particle[j].timcreation = lARXTime;
particle[j].tc = tex_mm;
particle[j].special = FADE_IN_AND_OUT | ROTATING | MODULATE_ROTATION | DISSIPATING;
particle[j].fparam = 0.0000001f;
particle[j].r = 0.1f;
particle[j].g = 0.1f;
particle[j].b = 0.1f;
}
}
}
EERIE_3D stiteangle;
EERIE_3D stitepos;
EERIE_3D stitescale;
EERIE_RGB stitecolor;
EERIE_3D av;
ARX_CHECK_NOT_NEG(arx_check_init);
av.x = lastpos.x - newpos.x;
av.y = lastpos.y - newpos.y;
av.z = lastpos.z - newpos.z;
TRUEVector_Normalize(&av);
float bubu = GetAngle(av.x, av.z, 0, 0);
float bubu1 = GetAngle(av.x, av.y, 0, 0);
stitepos.x = lastpos.x;
stitepos.y = lastpos.y;
stitepos.z = lastpos.z;
stiteangle.b = 180 - RAD2DEG(bubu);
stiteangle.a = 0;
stiteangle.g = 90 - RAD2DEG(bubu1);
stitecolor.r = 0.7f;
stitecolor.g = 0.7f;
stitecolor.b = 0.7f;
stitescale.x = 1;
stitescale.y = 1;
stitescale.z = 1;
eCurPos.x = lastpos.x;
eCurPos.y = lastpos.y;
eCurPos.z = lastpos.z;
return 1;
}
/**
* Get the angle in degrees for the PIDSource base object.
*
* @return The angle in degrees.
*/
double Gyro::PIDGet()
{
return GetAngle();
}
