Пользователь
-
Автор темы
- #1
чит миссает в мувы по кд а стенды фиксит, есть идеи как фиксить мувы(не детектить), либо норм резик который не срет в мувы для изучения
|
Вопрос Move resolve [lw]
- Автор темы Moriarty1667
- Дата начала
Пользователь
анимлееры...
берешь ребилд из десинквипа by soufiwi technology или отсюда: https://yougame.biz/threads/211753/
берешь ребилд из десинквипа by soufiwi technology или отсюда: https://yougame.biz/threads/211753/
Пользователь
-
Автор темы
- #3
Сойдет?
Код:
// This is an independent project of an individual developer. Dear PVS-Studio, please check it.
// PVS-Studio Static Code Analyzer for C, C++, C#, and Java: http://www.viva64.com
#include "animation_system.h"
#include "..\misc\misc.h"
#include "..\misc\logs.h"
std::deque <adjust_data> player_records[65];
void lagcompensation::fsn(ClientFrameStage_t stage)
{
if (stage != FRAME_NET_UPDATE_END)
return;
if (!g_cfg.ragebot.enable && !g_cfg.legitbot.enabled)
return;
for (auto i = 1; i < m_globals()->m_maxclients; i++) //-V807
{
auto e = static_cast<player_t*>(m_entitylist()->GetClientEntity(i));
if (e == g_ctx.local())
continue;
if (!valid(i, e))
continue;
auto time_delta = abs(TIME_TO_TICKS(e->m_flSimulationTime()) - m_globals()->m_tickcount);
if (time_delta > 1.0f / m_globals()->m_intervalpertick)
continue;
auto update = player_records[i].empty() || e->m_flSimulationTime() != e->m_flOldSimulationTime(); //-V550
if (update) //-V550
{
if (!player_records[i].empty() && (e->m_vecOrigin() - player_records[i].front().origin).LengthSqr() > 4096.0f)
for (auto& record : player_records[i])
record.invalid = true;
player_records[i].emplace_front(adjust_data());
update_player_animations(e);
while (player_records[i].size() > 32)
player_records[i].pop_back();
}
}
}
bool lagcompensation::valid(int i, player_t* e)
{
if (!g_cfg.ragebot.enable && !g_cfg.legitbot.enabled || !e->valid(false))
{
if (!e->is_alive())
{
is_dormant[i] = false;
player_resolver[i].reset();
g_ctx.globals.fired_shots[i] = 0;
g_ctx.globals.missed_shots[i] = 0;
}
else if (e->IsDormant())
is_dormant[i] = true;
player_records[i].clear();
return false;
}
return true;
}
void lagcompensation::extrapolate(player_t* player, Vector& origin, Vector& velocity, int& flags, bool wasonground)
{
static auto sv_gravity = m_cvar()->FindVar(crypt_str("sv_gravity"));
static auto sv_jump_impulse = m_cvar()->FindVar(crypt_str("sv_jump_impulse"));
if (!(flags & FL_ONGROUND))
velocity.z -= (m_globals()->m_frametime * sv_gravity->GetFloat());
else if (wasonground)
velocity.z = sv_jump_impulse->GetFloat();
const Vector mins = player->GetCollideable()->OBBMins();
const Vector max = player->GetCollideable()->OBBMaxs();
const Vector src = origin;
Vector end = src + (velocity * m_globals()->m_frametime);
Ray_t ray;
ray.Init(src, end, mins, max);
trace_t trace;
CTraceFilter filter;
filter.pSkip = (void*)(player);
m_trace()->TraceRay(ray, MASK_PLAYERSOLID, &filter, &trace);
if (trace.fraction != 1.f)
{
for (int i = 0; i < 2; i++)
{
velocity -= trace.plane.normal * velocity.Dot(trace.plane.normal);
const float dot = velocity.Dot(trace.plane.normal);
if (dot < 0.f)
{
velocity.x -= dot * trace.plane.normal.x;
velocity.y -= dot * trace.plane.normal.y;
velocity.z -= dot * trace.plane.normal.z;
}
end = trace.endpos + (velocity * (m_globals()->m_intervalpertick * (1.f - trace.fraction)));
ray.Init(trace.endpos, end, mins, max);
m_trace()->TraceRay(ray, MASK_PLAYERSOLID, &filter, &trace);
if (trace.fraction == 1.f)
break;
}
}
origin = trace.endpos;
end = trace.endpos;
end.z -= 2.f;
ray.Init(origin, end, mins, max);
m_trace()->TraceRay(ray, MASK_PLAYERSOLID, &filter, &trace);
flags &= ~(1 << 0);
if (trace.DidHit() && trace.plane.normal.z > 0.7f)
flags |= (1 << 0);
}
void lagcompensation::update_player_animations(player_t* e)
{
auto animstate = e->get_animation_state();
if (!animstate)
return;
player_info_t player_info;
if (!m_engine()->GetPlayerInfo(e->EntIndex(), &player_info))
return;
auto records = &player_records[e->EntIndex()];
if (records->empty())
return;
adjust_data* previous_record = nullptr;
auto record = &records->front();
const auto simtime_delta = e->m_flSimulationTime() - e->m_flOldSimulationTime();
const auto choked_ticks = ((simtime_delta / m_globals()->m_intervalpertick) + 0.5);
const auto simulation_tick_delta = choked_ticks - 2;
const auto delta_ticks = (std::clamp(TIME_TO_TICKS(m_engine()->GetNetChannelInfo()->GetLatency(1) + m_engine()->GetNetChannelInfo()->GetLatency(0)) + m_globals()->m_tickcount - TIME_TO_TICKS(e->m_flSimulationTime() + util::get_interpolation()), 0, 100)) - simulation_tick_delta;
if (delta_ticks > 0 && records->size() >= 2)
{
auto ticks_left = static_cast<int>(simulation_tick_delta);
ticks_left = std::clamp(ticks_left, 1, 10);
do
{
auto data_origin = record->origin;
auto data_velocity = record->velocity;
auto data_flags = record->flags;
extrapolate(e, data_origin, data_velocity, data_flags, !(e->m_fFlags() & FL_ONGROUND));
record->simulation_time += m_globals()->m_intervalpertick;
record->origin = data_origin;
record->velocity = data_velocity;
--ticks_left;
} while (ticks_left > 0);
}
else if (records->size() >= 2)
previous_record = &records->at(1);
AnimationLayer animlayers[15];
memcpy(animlayers, e->get_animlayers(), e->animlayer_count() * sizeof(AnimationLayer));
memcpy(record->layers, animlayers, e->animlayer_count() * sizeof(AnimationLayer));
auto backup_lower_body_yaw_target = e->m_flLowerBodyYawTarget();
auto backup_duck_amount = e->m_flDuckAmount();
auto backup_flags = e->m_fFlags();
auto backup_eflags = e->m_iEFlags();
if (previous_record)
{
auto velocity = e->m_vecVelocity();
auto was_in_air = e->m_fFlags() & FL_ONGROUND && previous_record->flags & FL_ONGROUND;
auto time_difference = max(m_globals()->m_intervalpertick, e->m_flSimulationTime() - previous_record->simulation_time);
auto origin_delta = e->m_vecOrigin() - previous_record->origin;
auto animation_speed = 0.0f;
if (!origin_delta.IsZero() && TIME_TO_TICKS(time_difference) > 0)
{
e->m_vecVelocity() = origin_delta * (1.0f / time_difference);
if (e->m_fFlags() & FL_ONGROUND && animlayers[11].m_flWeight > 0.0f && animlayers[11].m_flWeight < 1.0f && animlayers[11].m_flCycle > previous_record->layers[11].m_flCycle)
{
auto weapon = e->m_hActiveWeapon().Get();
if (weapon)
{
auto max_speed = 260.0f;
auto weapon_info = e->m_hActiveWeapon().Get()->get_csweapon_info();
if (weapon_info)
max_speed = e->m_bIsScoped() ? weapon_info->flMaxPlayerSpeedAlt : weapon_info->flMaxPlayerSpeed;
auto modifier = 0.35f * (1.0f - animlayers[11].m_flWeight);
if (modifier > 0.0f && modifier < 1.0f)
animation_speed = max_speed * (modifier + 0.55f);
}
}
if (animation_speed > 0.0f)
{
animation_speed /= e->m_vecVelocity().Length2D();
e->m_vecVelocity().x *= animation_speed;
e->m_vecVelocity().y *= animation_speed;
}
if (records->size() >= 3 && time_difference > m_globals()->m_intervalpertick)
{
auto previous_velocity = (previous_record->origin - records->at(2).origin) * (1.0f / time_difference);
if (!previous_velocity.IsZero() && !was_in_air)
{
auto current_direction = math::normalize_yaw(RAD2DEG(atan2(e->m_vecVelocity().y, e->m_vecVelocity().x)));
auto previous_direction = math::normalize_yaw(RAD2DEG(atan2(previous_velocity.y, previous_velocity.x)));
auto average_direction = current_direction - previous_direction;
average_direction = DEG2RAD(math::normalize_yaw(current_direction + average_direction * 0.5f));
auto direction_cos = cos(average_direction);
auto dirrection_sin = sin(average_direction);
auto velocity_speed = e->m_vecVelocity().Length2D();
e->m_vecVelocity().x = direction_cos * velocity_speed;
e->m_vecVelocity().y = dirrection_sin * velocity_speed;
}
}
if (!(e->m_fFlags() & FL_ONGROUND))
{
static auto sv_gravity = m_cvar()->FindVar(crypt_str("sv_gravity"));
auto fixed_timing = math::clamp(time_difference, m_globals()->m_intervalpertick, 1.0f);
e->m_vecVelocity().z -= sv_gravity->GetFloat() * fixed_timing * 0.5f;
}
else
e->m_vecVelocity().z = 0.0f;
}
}
e->m_iEFlags() &= ~0x1800;
if (e->m_fFlags() & FL_ONGROUND && e->m_vecVelocity().Length() > 0.0f && animlayers[6].m_flWeight <= 0.0f)
e->m_vecVelocity().Zero();
e->m_vecAbsVelocity() = e->m_vecVelocity();
e->m_bClientSideAnimation() = true;
if (is_dormant[e->EntIndex()])
{
is_dormant[e->EntIndex()] = false;
if (e->m_fFlags() & FL_ONGROUND)
{
animstate->m_bOnGround = true;
animstate->m_bInHitGroundAnimation = false;
}
animstate->time_since_in_air() = 0.0f;
animstate->m_flGoalFeetYaw = math::normalize_yaw(animstate->m_flEyeYaw);
}
auto updated_animations = false;
c_baseplayeranimationstate state;
memcpy(&state, animstate, sizeof(c_baseplayeranimationstate));
if (previous_record)
{
memcpy(e->get_animlayers(), previous_record->layers, e->animlayer_count() * sizeof(AnimationLayer));
auto ticks_chocked = 1;
auto simulation_ticks = TIME_TO_TICKS(e->m_flSimulationTime() - previous_record->simulation_time);
if (simulation_ticks > 0 && simulation_ticks < 17)
ticks_chocked = simulation_ticks;
if (ticks_chocked > 1)
{
auto land_time = 0.0f;
auto land_in_cycle = false;
auto is_landed = false;
auto on_ground = false;
if (animlayers[4].m_flCycle < 0.5f && (!(e->m_fFlags() & FL_ONGROUND) || !(previous_record->flags & FL_ONGROUND)))
{
land_time = e->m_flSimulationTime() - animlayers[4].m_flPlaybackRate * animlayers[4].m_flCycle;
land_in_cycle = land_time >= previous_record->simulation_time;
}
auto duck_amount_per_tick = (e->m_flDuckAmount() - previous_record->duck_amount) / ticks_chocked;
for (auto i = 0; i < ticks_chocked; ++i)
{
auto simulated_time = previous_record->simulation_time + TICKS_TO_TIME(i);
if (duck_amount_per_tick)
e->m_flDuckAmount() = previous_record->duck_amount + duck_amount_per_tick * (float)i;
on_ground = e->m_fFlags() & FL_ONGROUND;
if (land_in_cycle && !is_landed)
{
if (land_time <= simulated_time)
{
is_landed = true;
on_ground = true;
}
else
on_ground = previous_record->flags & FL_ONGROUND;
}
if (on_ground)
e->m_fFlags() |= FL_ONGROUND;
else
e->m_fFlags() &= ~FL_ONGROUND;
auto simulated_ticks = TIME_TO_TICKS(simulated_time);
auto backup_curtime = m_globals()->m_curtime;
auto backup_frametime = m_globals()->m_frametime;
auto backup_realtime = m_globals()->m_realtime;
auto backup_framecount = m_globals()->m_framecount;
auto backup_tickcount = m_globals()->m_tickcount;
auto backup_interpolation_amount = m_globals()->m_interpolation_amount;
m_globals()->m_curtime = e->m_flSimulationTime();
m_globals()->m_frametime = m_globals()->m_intervalpertick;
auto realtime_backup = m_globals()->m_realtime;
auto curtime = m_globals()->m_curtime;
auto frametime = m_globals()->m_frametime;
auto absoluteframetime = m_globals()->m_absoluteframetime;
auto framecount = m_globals()->m_framecount;
auto tickcount = m_globals()->m_tickcount;
auto interpolation_amount = m_globals()->m_interpolation_amount;
int ticks = TIME_TO_TICKS(record->simulation_time);
m_globals()->m_realtime = realtime_backup;
m_globals()->m_curtime = simulated_time;
m_globals()->m_frametime = m_globals()->m_intervalpertick;
m_globals()->m_absoluteframetime = m_globals()->m_intervalpertick;
m_globals()->m_framecount = ticks;
m_globals()->m_tickcount = ticks;
m_globals()->m_interpolation_amount = 0.f;
e->update_clientside_animation();
m_globals()->m_realtime = realtime_backup;
m_globals()->m_curtime = curtime;
m_globals()->m_frametime = frametime;
m_globals()->m_absoluteframetime = absoluteframetime;
m_globals()->m_framecount = framecount;
m_globals()->m_tickcount = tickcount;
m_globals()->m_interpolation_amount = interpolation_amount;
updated_animations = true;
}
}
}
if (!updated_animations)
{
g_ctx.globals.updating_animation = true;
e->update_clientside_animation();
g_ctx.globals.updating_animation = false;
}
memcpy(animstate, &state, sizeof(c_baseplayeranimationstate));
auto setup_matrix = [&](player_t* e, AnimationLayer* layers, const int& matrix) -> void
{
e->invalidate_physics_recursive(8);
AnimationLayer backup_layers[15];
memcpy(backup_layers, e->get_animlayers(), e->animlayer_count() * sizeof(AnimationLayer));
memcpy(e->get_animlayers(), layers, e->animlayer_count() * sizeof(AnimationLayer));
switch (matrix)
{
case MAIN:
e->setup_bones_fixed(record->matrixes_data.main, BONE_USED_BY_ANYTHING);
break;
case NONE:
e->setup_bones_fixed(record->matrixes_data.zero, BONE_USED_BY_HITBOX);
break;
case FIRST:
e->setup_bones_fixed(record->matrixes_data.first, BONE_USED_BY_HITBOX);
break;
case SECOND:
e->setup_bones_fixed(record->matrixes_data.second, BONE_USED_BY_HITBOX);
break;
}
memcpy(e->get_animlayers(), backup_layers, e->animlayer_count() * sizeof(AnimationLayer));
};
if (!player_info.fakeplayer && g_ctx.local()->is_alive() && e->m_iTeamNum() != g_ctx.local()->m_iTeamNum() && !g_cfg.legitbot.enabled)
{
animstate->m_flGoalFeetYaw = previous_goal_feet_yaw[e->EntIndex()];
g_ctx.globals.updating_animation = true;
e->update_clientside_animation();
g_ctx.globals.updating_animation = false;
previous_goal_feet_yaw[e->EntIndex()] = animstate->m_flGoalFeetYaw;
memcpy(animstate, &state, sizeof(c_baseplayeranimationstate));
animstate->m_flGoalFeetYaw = math::normalize_yaw(e->m_angEyeAngles().y);
g_ctx.globals.updating_animation = true;
e->update_clientside_animation();
g_ctx.globals.updating_animation = false;
setup_matrix(e, animlayers, NONE);
memcpy(animstate, &state, sizeof(c_baseplayeranimationstate));
player_resolver[e->EntIndex()].goal_feet_yaw = animstate->m_flGoalFeetYaw;
memcpy(player_resolver[e->EntIndex()].resolver_layers[0], e->get_animlayers(), e->animlayer_count() * sizeof(AnimationLayer));
animstate->m_flGoalFeetYaw = math::normalize_yaw(e->m_angEyeAngles().y + 60);
g_ctx.globals.updating_animation = true;
e->update_clientside_animation();
g_ctx.globals.updating_animation = false;
setup_matrix(e, animlayers, FIRST);
memcpy(animstate, &state, sizeof(c_baseplayeranimationstate));
memcpy(player_resolver[e->EntIndex()].resolver_layers[2], e->get_animlayers(), e->animlayer_count() * sizeof(AnimationLayer));
animstate->m_flGoalFeetYaw = math::normalize_yaw(e->m_angEyeAngles().y - 60);
g_ctx.globals.updating_animation = true;
e->update_clientside_animation();
g_ctx.globals.updating_animation = false;
setup_matrix(e, animlayers, SECOND);
memcpy(animstate, &state, sizeof(c_baseplayeranimationstate));
memcpy(player_resolver[e->EntIndex()].resolver_layers[1], e->get_animlayers(), e->animlayer_count() * sizeof(AnimationLayer));
player_resolver[e->EntIndex()].initialize(e, record, previous_goal_feet_yaw[e->EntIndex()], animstate->m_flPitch);
player_resolver[e->EntIndex()].resolve_yaw();
player_resolver[e->EntIndex()].StoreAntifreestand();
if (g_cfg.player_list.low_delta[e->EntIndex()])
{
switch (record->side)
{
case RESOLVER_FIRST:
record->side = RESOLVER_LOW_FIRST;
break;
case RESOLVER_SECOND:
record->side = RESOLVER_LOW_SECOND;
break;
case RESOLVER_LOW_FIRST:
record->side = RESOLVER_FIRST;
break;
case RESOLVER_LOW_SECOND:
record->side = RESOLVER_SECOND;
break;
}
}
else
{
for (auto it = lagcompensation::get().player_sets.begin(); it != lagcompensation::get().player_sets.end(); ++it)
if (it->id == player_info.steamID64 && it->res_type == HISTORY_LOW)
{
switch (record->side)
{
case RESOLVER_FIRST:
record->side = RESOLVER_LOW_FIRST;
break;
case RESOLVER_SECOND:
record->side = RESOLVER_LOW_SECOND;
break;
case RESOLVER_LOW_FIRST:
record->side = RESOLVER_FIRST;
break;
case RESOLVER_LOW_SECOND:
record->side = RESOLVER_SECOND;
break;
case RESOLVER_NORM:
record->side = RESOLVER_FIRST;
break;
case RESOLVER_NORM2:
record->side = RESOLVER_SECOND;
break;
}
break;
}
}
switch (record->side)
{
case RESOLVER_ORIGINAL:
animstate->m_flGoalFeetYaw = previous_goal_feet_yaw[e->EntIndex()];
break;
case RESOLVER_ZERO:
animstate->m_flGoalFeetYaw = math::normalize_yaw(e->m_angEyeAngles().y);
break;
case RESOLVER_FIRST:
animstate->m_flGoalFeetYaw = math::normalize_yaw(e->m_angEyeAngles().y + e->get_max_desync_delta());
break;
case RESOLVER_SECOND:
animstate->m_flGoalFeetYaw = math::normalize_yaw(e->m_angEyeAngles().y - e->get_max_desync_delta());
break;
case RESOLVER_LOW_FIRST:
animstate->m_flGoalFeetYaw = math::normalize_yaw(e->m_angEyeAngles().y + min(22.0f, e->get_max_desync_delta()));
break;
case RESOLVER_LOW_SECOND:
animstate->m_flGoalFeetYaw = math::normalize_yaw(e->m_angEyeAngles().y - min(22.0f, e->get_max_desync_delta()));
break;
case RESOLVER_NORM:
animstate->m_flGoalFeetYaw = math::normalize_yaw(e->m_angEyeAngles().y + min(24.0f, e->get_max_desync_delta()));
break;
case RESOLVER_NORM2:
animstate->m_flGoalFeetYaw = math::normalize_yaw(e->m_angEyeAngles().y - min(24.0f, e->get_max_desync_delta()));
break;
case RESOLVER_AD:
animstate->m_flGoalFeetYaw = math::normalize_yaw(e->m_angEyeAngles().y + min(40.0f, e->get_max_desync_delta()));
break;
case RESOLVER_AB:
animstate->m_flGoalFeetYaw = math::normalize_yaw(e->m_angEyeAngles().y - min(40.0f, e->get_max_desync_delta()));
break;
}
animstate->m_flPitch = player_resolver[e->EntIndex()].resolve_pitch();
}
g_ctx.globals.updating_animation = true;
e->update_clientside_animation();
g_ctx.globals.updating_animation = false;
setup_matrix(e, animlayers, MAIN);
memcpy(e->m_CachedBoneData().Base(), record->matrixes_data.main, e->m_CachedBoneData().Count() * sizeof(matrix3x4_t));
e->m_flLowerBodyYawTarget() = backup_lower_body_yaw_target;
e->m_flDuckAmount() = backup_duck_amount;
e->m_fFlags() = backup_flags;
e->m_iEFlags() = backup_eflags;
memcpy(e->get_animlayers(), animlayers, e->animlayer_count() * sizeof(AnimationLayer));
memcpy(player_resolver[e->EntIndex()].previous_layers, animlayers, e->animlayer_count() * sizeof(AnimationLayer));
record->store_data(e, false);
if (e->m_flSimulationTime() < e->m_flOldSimulationTime())
record->invalid = true;
}
Последнее редактирование:
Пользователь
onetap v2 resolver
C++:
if ( m_pPlayer->m_vecVelocity( ).Length2D( ) > 0.1f && !( m_pLayers[ 12 ].m_flWeight * 1000.0f ) && ( m_pLayers[ 6 ].m_flWeight * 1000.0f ) == ( PreviousLayers[ 6 ].m_flWeight * 1000.0f ) ) {
float DeltaFirst = abs( m_pLayers[ 6 ].m_flPlaybackRate - m_pResolverAnimLayers[ 0 ][ 6 ].m_flPlaybackRate );
float DeltaSecond = abs( m_pLayers[ 6 ].m_flPlaybackRate - m_pResolverAnimLayers[ 1 ][ 6 ].m_flPlaybackRate );
float DeltaThird = abs( m_pLayers[ 6 ].m_flPlaybackRate - m_pResolverAnimLayers[ 2 ][ 6 ].m_flPlaybackRate );
if ( DeltaFirst < DeltaSecond || DeltaSecond <= DeltaThird || ( DeltaSecond * 1000.0f ) ) {
if ( DeltaFirst >= DeltaThird && DeltaSecond > DeltaThird && !( DeltaThird * 1000.0f ) ) {
m_pSide = 1;
m_pType = 1;
}
}
else {
m_pSide = -1;
m_pType = 1;
}
}
а где детект сайда, да и 12 леер тут не нужен
он знает что 12 леер там не нужен (чел дал ресольвер в2 вантапа там он был ) во вторых тебе "чек стенд" это не детект сайд, он тоже не нужен
так на секунду скажу, что в 2 вантапе этот чек был
тут вопрос про мувы ( а не про ненужный парт в ванпасте )
Похожие темы
