Skocz do zawartości

hollywoood

 Pokaż profil  Zobacz aktywność

  • Postów

    42

  • Dołączył

  • Dostępny

  • Donacje

    0.00 PLN 

  • Diamenty

    0 [ Podaruj ]

 Typ zawartości 

Posty opublikowane przez hollywoood

    [Source] shitware

    w Gotowe kody źródłowe

    free hourboost

    w Konkursy / giveaway'e

    Opublikowano

    Cześć, jako iż dużo osób potrzebuje godzin żeby ich konta były bardziej "legitne" i nie wszyscy potrafią idlować na vps, itp, to mam dla was giwałej hourboosta na bodajże miesiąc. Pierwsze 10 osób, które wyślą mi w poście swój profil dostaną darmowego hourboosta gl&hf.

    Wymagania:

    1. 2 miesiące na forum

    2. Mniej niż 2 warny.

     

    #info idler działa chyba na mobilnym tokenie jeśli masz shared_secret, jeśli nie to możesz z guardem na mail'a. I przede wszystkim dziękuje użytkownikowi  Kakashi21  za wytłumaczenie mi co i jak z tym idlowaniem  :D

     

    @osoby podłaczone pod idlera:

    wiorekk -  http://steamcommunity.com/id/elwioras

    blondyn135- http://steamcommunity.com/profiles/76561198373327485

    haxiorexx- http://steamcommunity.com/id/2137______

    http://steamcommunity.com/id/xxxwhiteniggerxxx

    0

    b1g ayyware 4.0

    w Gotowe kody źródłowe

    Opublikowano ·
    Edytowane przez hollywoood

     

     

    Odrazu pisze nie jestem autrem cheata , jest to ulepszony "senstaion.cc " sprawdzalem nawet kosi na hvh.

     

    "https://www.youtube.com/watch?v=sXsOBpRqoEA" - prezentacja cheata

     

    virus - https://www.virustotal.com/#/file/986c35a7266860a87f2fb0bc10e5e3ab5c7e07305bb98866d601a5a3a80b58f1/detection

     

     

    Credits:

    - me ( yolofster \ flox)

    - white ( aka imanty coder big friend love u)

    - my mom

    - UC

    - blank aka sleepy (BIG FRIEND)

    - RUVIK (BIG FRIEND)

    - AVOZ SOURCE ( NADE NAMES)

    - AIMTUX

     

    cheat wziety z zagranicznego forum moze wam sie przyda

     

    mozesz dac + :D

     

    jakbyś chciał wiedziec nie jest to nawet sensation XDDD

    0

    [Source] Injector

    w Gotowe kody źródłowe

    Opublikowano

    Zauwazylem ze duzo osob szuka injector wiec niech zrobi sobie swojego. Uzywam ok. 1 miesiac. Musicie go zabezpieczyc pierw pozmieniac opcje i dodac junkcody i wgl zeby byl ud.

     

     

    http://prntscr.com/gakatl tak wyglada , zakrylam opcje poniewaz byly tam brzydkie slowa :D

     

     

    https://www.virustotal.com/#/file/6cd58f6cca9d0e4dde05bc2dcad464a8a9f14974e2fd97cedd8ac6833c0fbef7/detection

     

    raczej virusa nie ma xd

    injector 6/10 :P

    0

    [SOURCE] Fake Kidua?

    w Gotowe kody źródłowe

    Opublikowano

    Fake Kidua source. (Najprawdopodobniej Dingosquad)

     

    Glovesy crashują i coś jeszcze, ale to raczej problemem nie jest.

     

    Menu:

    https://i.gyazo.com/7b92aee37c3543692d4682078bae3a97.mp4

     

    Menu jest identyczne. Tylko nazwa inna :v

     

    Credits: Nie jestem pewny. Dostałem to od znajomego. Wiem tyle, ze z jakiegoś ruskiego forum.

     

    Skan: https://www.virustotal.com/#/file/2aa4aad7ccd4026863a419b8c73c833b327f2e7ef229c8f132598712bdf05742/detection

    free weekend fake 100% xD

    0

    Szukam jakiegoś dobrego resolvera

    w Dyskusje / problemy związane z programowaniem

    Opublikowano

    Ten od pycache podobno daje rade.

     

    Backtrack.h

     

     

    #pragma once
 
struct CTickRecord;
 
struct CValidTick {
	explicit operator CTickRecord() const;
 
	explicit operator bool() const noexcept {
		return m_flSimulationTime > 0.f;
	}
 
	float m_flPitch = 0.f;
	float m_flYaw = 0.f;
	float m_flSimulationTime = 0.f;
	CBaseEntity* m_pEntity = nullptr;
};
 
struct CTickRecord {
	CTickRecord() {}
	CTickRecord(CBaseEntity* ent) {
		m_flLowerBodyYawTarget = ent->GetLowerBodyYawTarget();
		m_angEyeAngles = ent->GetEyeAngles();
		m_flCycle = ent->GetCycle();
		m_flSimulationTime = ent->GetSimulationTime();
		m_nSequence = ent->GetSequence();
		m_vecOrigin = ent->GetOrigin();
		m_vecVelocity = ent->GetVelocity();
		m_flPoseParameter = ent->GetPoseParameters();
		m_angAbsAngles = ent->GetAbsAngles();
		m_vecAbsOrigin = ent->GetAbsOrigin();
		tickcount = 0;
	}
 
	explicit operator bool() const noexcept {
		return m_flSimulationTime > 0.f;
	}
 
	bool operator>(const CTickRecord& others) {
		return (m_flSimulationTime > others.m_flSimulationTime);
	}
	bool operator>=(const CTickRecord& others) {
		return (m_flSimulationTime >= others.m_flSimulationTime);
	}
	bool operator<(const CTickRecord& others) {
		return (m_flSimulationTime < others.m_flSimulationTime);
	}
	bool operator<=(const CTickRecord& others) {
		return (m_flSimulationTime <= others.m_flSimulationTime);
	}
	bool operator==(const CTickRecord& others) {
		return (m_flSimulationTime == others.m_flSimulationTime);
	}
 
	float m_flLowerBodyYawTarget = 0.f;
	QAngle m_angEyeAngles = QAngle(0, 0, 0);
	float m_flCycle = 0.f;
	float m_flSimulationTime = 0.f;
	int m_nSequence = 0;
	Vector m_vecOrigin = Vector(0, 0, 0);
	Vector m_vecAbsOrigin = Vector(0, 0, 0);
	Vector m_vecVelocity = Vector(0, 0, 0);
	std::array<float, 24> m_flPoseParameter = {};
	QAngle m_angAbsAngles = QAngle(0, 0, 0);
	CValidTick validtick;
	int tickcount = 0;
};
 
inline CValidTick::operator CTickRecord() const{
	CTickRecord rec(m_pEntity);
	rec.m_angEyeAngles.x = this->m_flPitch;
	rec.m_angEyeAngles.y = this->m_flYaw;
	rec.m_flSimulationTime = this->m_flSimulationTime;
	return rec;
} 

     

     

     

    Resolver.h

     

     

    #pragma once
 
enum class ResolveMode : int {
	OFF = 0,
	FORCE,
	DELTA,
	STEADY,
	TICKMODULO,
	ALL
};
 
class CResolveInfo {
	friend class CResolver;
protected:
	std::deque<CTickRecord> m_sRecords;
	bool	m_bEnemyShot; //priority
	bool	m_bLowerBodyYawChanged;
	bool	m_bBacktrackThisTick;
};
 
#define Resolver CResolver::GetInstance()
 
class CResolver {
	friend class CLagcompensation;
	friend class CBacktracking;
 
	IMPLEMENT_SINGLETON(CResolver);
 
public:
	void StoreVars(CBaseEntity* Entity);
	void StoreVars(CBaseEntity* Entity, QAngle ang, float lby, float simtime, float tick);
 
	void Resolve(CBaseEntity* ent);
 
	bool& LowerBodyYawChanged(CBaseEntity* ent);
	bool& BacktrackThisTick(CBaseEntity* ent);
	
private:
	CTickRecord GetShotRecord(CBaseEntity*);
	bool HasStaticRealAngle(int index, float tolerance = 15.f);
	bool HasStaticRealAngle(const std::deque<CTickRecord>& l, float tolerance = 15.f);
	bool HasStaticYawDifference(const std::deque<CTickRecord>& l, float tolerance = 15.f);
	bool HasSteadyDifference(const std::deque<CTickRecord>& l, float tolerance = 15.f);
	int GetDifferentDeltas(const std::deque<CTickRecord>& l, float tolerance = 15.f);
	int GetDifferentLBYs(const std::deque<CTickRecord>& l, float tolerance = 15.f);
	float GetLBYByComparingTicks(const std::deque<CTickRecord>& l);
	float GetDeltaByComparingTicks(const std::deque<CTickRecord>& l);
	bool DeltaKeepsChanging(const std::deque<CTickRecord>& cur, float tolerance = 15.f);
	bool LBYKeepsChanging(const std::deque<CTickRecord>& cur, float tolerance = 15.f);
	bool IsEntityMoving(CBaseEntity* ent);
 
private:
	std::array<CResolveInfo, 32> m_arrInfos;
};
 
 
 
const inline float GetDelta(float a, float  {
	return abs(M::ClampYaw(a - );
}
 
const inline float LBYDelta(const CTickRecord& v) {
	return v.m_angEyeAngles.y - v.m_flLowerBodyYawTarget;
}
 
const inline bool IsDifferent(float a, float b, float tolerance = 10.f) {
	return (GetDelta(a,  > tolerance);
} 

     

     

     

    Resolver.cpp

     

     

    include "Refund.h"
 
void CResolver::Resolve(CBaseEntity* ent) {
	auto cur = m_arrInfos.at(ent->GetIndex()).m_sRecords;
	if (cur.size() < 2)
		return;
	if (Config->GetValue<int>("Resolver", "Mode") == static_cast<int>(ResolveMode::OFF))
		return;
	else if (Config->GetValue<int>("Resolver", "Mode") == static_cast<int>(ResolveMode::FORCE)) {
		ent->m_angEyeAngles().y = cur.front().m_flLowerBodyYawTarget;
	}
	else if (Config->GetValue<int>("Resolver", "Mode") == static_cast<int>(ResolveMode::DELTA)) {
		ent->m_angEyeAngles().y = LBYDelta(cur.front());
	}
	else if (Config->GetValue<int>("Resolver", "Mode") == static_cast<int>(ResolveMode::STEADY)) {
		if (cur.size() <= 1)
			return;
		float tickdif = static_cast<float>(cur.front().tickcount - cur.at(1).tickcount);
		float lbydif = GetDelta(cur.front().m_flLowerBodyYawTarget, cur.at(1).m_flLowerBodyYawTarget);
		float ntickdif = static_cast<float>(G::UserCmd->tick_count - cur.front().tickcount);
		ent->m_angEyeAngles().y = (lbydif / tickdif) * ntickdif;
	}
	else if (Config->GetValue<int>("Resolver", "Mode") == static_cast<int>(ResolveMode::TICKMODULO)) {
		ent->m_angEyeAngles().y = ent->GetEyeAngles().y - GetDeltaByComparingTicks(cur);
	}
	else if (Config->GetValue<int>("Resolver", "Mode") == static_cast<int>(ResolveMode::ALL)) {
		if (Backtracking->CanBacktrackShot(GetShotRecord(ent)))
			m_arrInfos.at(ent->entindex()).m_sRecords.erase(std::remove(m_arrInfos.at(ent->entindex()).m_sRecords.begin(), m_arrInfos.at(ent->entindex()).m_sRecords.end(), GetShotRecord(ent)), m_arrInfos.at(ent->entindex()).m_sRecords.end());
		else if (IsEntityMoving(ent))
			ent->m_angEyeAngles().y = ent->GetLowerBodyYawTarget();
		else if (HasStaticRealAngle(cur))
			ent->m_angEyeAngles().y = (cur.front().m_flLowerBodyYawTarget) + (M::RandomFloat(0.f, 1.f) > 0.5f ? 10 : -10);
		else if (HasStaticYawDifference(cur))
			ent->m_angEyeAngles().y = ent->GetEyeAngles().y - (cur.front().m_angEyeAngles.y - cur.front().m_flLowerBodyYawTarget);
		else if (HasSteadyDifference(cur)) {
			float tickdif = static_cast<float>(cur.front().tickcount - cur.at(1).tickcount);
			float lbydif = GetDelta(cur.front().m_flLowerBodyYawTarget, cur.at(1).m_flLowerBodyYawTarget);
			float ntickdif = static_cast<float>(G::UserCmd->tick_count - cur.front().tickcount);
			ent->m_angEyeAngles().y = (lbydif / tickdif) * ntickdif;
		}
		else if (DeltaKeepsChanging(cur))
			ent->m_angEyeAngles().y = ent->GetEyeAngles().y - GetDeltaByComparingTicks(cur);
		else if (LBYKeepsChanging(cur))
			ent->m_angEyeAngles().y = GetLBYByComparingTicks(cur);
		else
			ent->m_angEyeAngles().y = ent->GetEyeAngles().y + 180;
	}
}
 
 
bool& CResolver::LowerBodyYawChanged(CBaseEntity* ent) {
	return m_arrInfos.at(ent->GetIndex()).m_bLowerBodyYawChanged;
}
 
void CResolver::StoreVars(CBaseEntity* ent) {
	if (m_arrInfos.at(ent->GetIndex()).m_sRecords.size() >= static_cast<size_t>(Config->GetValue<int>("Resolver", "Ticks")))
		m_arrInfos.at(ent->GetIndex()).m_sRecords.pop_back();
	m_arrInfos.at(ent->GetIndex()).m_sRecords.push_front(CTickRecord(ent));
}
 
void CResolver::StoreVars(CBaseEntity* ent, QAngle ang, float lby, float simtime, float tick) {
	if (m_arrInfos.at(ent->GetIndex()).m_sRecords.size() >= static_cast<size_t>(Config->GetValue<int>("Resolver", "Ticks")))
		m_arrInfos.at(ent->GetIndex()).m_sRecords.pop_back();
	m_arrInfos.at(ent->GetIndex()).m_sRecords.push_front(CTickRecord(ent));
}
 
bool& CResolver::BacktrackThisTick(CBaseEntity* ent) {
	return m_arrInfos.at(ent->GetIndex()).m_bBacktrackThisTick;
}
 
CTickRecord CResolver::GetShotRecord(CBaseEntity* ent) {
	for (auto cur : m_arrInfos[ent->entindex()].m_sRecords) {
		if (cur.validtick)
			return CTickRecord(cur);
	}
	return CTickRecord();
}
 
bool CResolver::HasStaticRealAngle(const std::deque<CTickRecord>& l, float tolerance) {
	auto minmax = std::minmax_element(std::begin(l), std::end(l), [](const CTickRecord& t1, const CTickRecord& t2) { return t1.m_flLowerBodyYawTarget < t2.m_flLowerBodyYawTarget; });
	return (fabs(minmax.first->m_flLowerBodyYawTarget - minmax.second->m_flLowerBodyYawTarget) <= tolerance);
}
 
bool CResolver::HasStaticRealAngle(int index, float tolerance) {
	return HasStaticRealAngle(m_arrInfos[index].m_sRecords, tolerance);
}
 
bool CResolver::HasStaticYawDifference(const std::deque<CTickRecord>& l, float tolerance) {
	for (auto i = l.begin(); i < l.end() - 1;) {
		if (GetDelta(LBYDelta(*i), LBYDelta(*++i)) > tolerance)
			return false;
	}
	return true;
}
 
bool CResolver::HasSteadyDifference(const std::deque<CTickRecord>& l, float tolerance) {
	size_t misses = 0;
	for (size_t i = 0; i < l.size() - 1; i++) {
		float tickdif = static_cast<float>(l.at(i).m_flSimulationTime - l.at(i + 1).tickcount);
		float lbydif = GetDelta(l.at(i).m_flLowerBodyYawTarget, l.at(i + 1).m_flLowerBodyYawTarget);
		float ntickdif = static_cast<float>(G::UserCmd->tick_count - l.at(i).tickcount);
		if (((lbydif / tickdif) * ntickdif) > tolerance) misses++;
	}
	return (misses <= (l.size() / 3));
}
 
int CResolver::GetDifferentDeltas(const std::deque<CTickRecord>& l, float tolerance) {
	std::vector<float> vec;
	for (auto var : l) {
		float curdelta = LBYDelta(var);
		bool add = true;
		for (auto fl : vec) {
			if (!IsDifferent(curdelta, fl, tolerance))
				add = false;
		}
		if (add)
			vec.push_back(curdelta);
	}
	return vec.size();
}
 
int CResolver::GetDifferentLBYs(const std::deque<CTickRecord>& l, float tolerance) {
	std::vector<float> vec;
	for (auto var : l) {
		float curyaw = var.m_flLowerBodyYawTarget;
		bool add = true;
		for (auto fl : vec) {
			if (!IsDifferent(curyaw, fl, tolerance))
				add = false;
		}
		if (add)
			vec.push_back(curyaw);
	}
	return vec.size();
}
 
float CResolver::GetLBYByComparingTicks(const std::deque<CTickRecord>& l) {
	int modulo = Config->GetValue<int>("Resolver", "Modulo");
	int difangles = GetDifferentLBYs(l);
	int inc = modulo * difangles;
	for (auto var : l) {
		for (int lasttick = var.tickcount; lasttick < G::UserCmd->tick_count; lasttick += inc) {
			if (lasttick == G::UserCmd->tick_count)
				return var.m_flLowerBodyYawTarget;
		}
	}
	return 0.f;
}
 
float CResolver::GetDeltaByComparingTicks(const std::deque<CTickRecord>& l) {
	int modulo = Config->GetValue<int>("Resolver", "Modulo");
	int difangles = GetDifferentDeltas(l);
	int inc = modulo * difangles;
	for (auto var : l) {
		for (int lasttick = var.tickcount; lasttick < G::UserCmd->tick_count; lasttick += inc) {
			if (lasttick == G::UserCmd->tick_count)
				return LBYDelta(var);
		}
	}
	return 0.f;
}
 
bool CResolver::DeltaKeepsChanging(const std::deque<CTickRecord>& cur, float tolerance) {
	return (GetDifferentDeltas(cur) > (int) cur.size() / 2);
}
 
bool CResolver::LBYKeepsChanging(const std::deque<CTickRecord>& cur, float tolerance) {
	return (GetDifferentLBYs(cur, tolerance) > (int)cur.size() / 2);
}
 
bool CResolver::IsEntityMoving(CBaseEntity* ent) {
	return (ent->GetVelocity().Length2D() > 0.1f && ent->GetFlags() & FL_ONGROUND);
} 

     

     

    dzięki jutro ztestuje :P

    0
 Społeczność
Zapoznaj się
 Pomoc
×
×
  • Dodaj nową pozycję...

Powiadomienie o plikach cookie

Umieściliśmy na Twoim urządzeniu pliki cookie, aby pomóc Ci usprawnić przeglądanie strony. Możesz dostosować ustawienia plików cookie, w przeciwnym wypadku zakładamy, że wyrażasz na to zgodę. Regulamin. Polityka prywatności