C++ Script thread[1.18] - NextGenUpdate

07-27-2014, 05:45 PM #1

OLDSCHOOLMODZHD

Uber Haxor

556

Posts

18,603

Reputation

20

Credits

NextGenUpdate Elite

Apr 2013

NextGenUpdate

(adsbygoogle = window.adsbygoogle || []).push({});

If you want me to add anything just post it below Happy

hopefully more people will be making sprx and c++ tools Smile

Prestige scroller bar

    

int PrestigeNumber[18];

bool storeP[18];

bool Prestige[18];

//huds

int PrestBG[18];

int Prest0[18];

int Prest1[18];

int Prest2[18];

int Prest3[18];

int Prest4[18];

int Prest5[18];

int Prest6[18];

int Prest7[18];

int Prest8[18];

int Prest9[18];

int Prest10[18];

int Prest11[18];

int Prest12[18];

int Prest13[18];

int Prest14[18];

int Prest15[18];

int Prest16[18];



void RunPrestige(int client)

{

	if(!storeP[client])

	{

		PrestBG[client] = HUDS::SetShader(client, "white", 1, 50, -110, 300, 0, 0, 0, 0, 0);

		Prest0[client] = HUDS::SetShader(client, "rank_com", 70, 70, 290, 290, 0, 255, 255, 255, 0);

		Prest1[client] = HUDS::SetShader(client, "rank_prestige01", 50, 50, 220, 300, 0, 255, 255, 255, 0);

		Prest2[client] = HUDS::SetShader(client, "rank_prestige02", 50, 50, 150, 300, 0, 255, 255, 255, 0);

		Prest3[client] = HUDS::SetShader(client, "rank_prestige03", 50, 50, 80, 300, 0, 255, 255, 255, 0);

		Prest4[client] = HUDS::SetShader(client, "rank_prestige04", 50, 50, 10, 300, 0, 255, 255, 255, 0);

		Prest5[client] = HUDS::SetShader(client, "rank_prestige05", 50, 50, -60, 300, 0, 255, 255, 255, 0);

		Prest6[client] = HUDS::SetShader(client, "rank_prestige06", 50, 50, -130, 300, 0, 255, 255, 255, 0);

		Prest7[client] = HUDS::SetShader(client, "rank_prestige07", 50, 50, -200, 300, 0, 255, 255, 255, 0);

		Prest8[client] = HUDS::SetShader(client, "rank_prestige08", 50, 50, -270, 300, 0, 255, 255, 255, 0);

		Prest9[client] = HUDS::SetShader(client, "rank_prestige09", 50, 50, -340, 300, 0, 255, 255, 255, 0);

		Prest10[client] = HUDS::SetShader(client, "rank_prestige10", 50, 50, -410, 300, 0, 255, 255, 255, 0);



		HUDS::FadeOverTime(PrestBG[client], 1, ShaderR[client], ShaderG[client], ShaderB[client], 150);

		HUDS::ScaleOverTime(PrestBG[client], 400, 890, 50);

		HUDS::FadeOverTime(Prest0[client], 200, 255, 255, 255, 255);

		HUDS::FadeOverTime(Prest1[client], 200, 255, 255, 255, 255);

		HUDS::FadeOverTime(Prest2[client], 200, 255, 255, 255, 255);

		HUDS::FadeOverTime(Prest3[client], 200, 255, 255, 255, 255);

		HUDS::FadeOverTime(Prest4[client], 200, 255, 255, 255, 255);

		HUDS::FadeOverTime(Prest5[client], 200, 255, 255, 255, 255);

	        HUDS::FadeOverTime(Prest6[client], 200, 255, 255, 255, 255);

		HUDS::FadeOverTime(Prest7[client], 200, 255, 255, 255, 255);

                HUDS::FadeOverTime(Prest8[client], 200, 255, 255, 255, 255);

		HUDS::FadeOverTime(Prest9[client], 200, 255, 255, 255, 255);

	        HUDS::FadeOverTime(Prest10[client], 200, 255, 255, 255, 255);

		P restige[client] = true;

		storeP[client] = true;

	}

	else

	{

		HUDS::FadeOverTime(PrestBG[client], 1, 0, 0, 0, 150);

		HUDS::ScaleOverTime(PrestBG[client], 400, 890, 50);

		HUDS::FadeOverTime(Prest0[client], 200, 255, 255, 255, 255);

		HUDS::FadeOverTime(Prest1[client], 200, 255, 255, 255, 255);

		HUDS::FadeOverTime(Prest2[client], 200, 255, 255, 255, 255);

		HUDS::FadeOverTime(Prest3[client], 200, 255, 255, 255, 255);

		HUDS::FadeOverTime(Prest4[client], 200, 255, 255, 255, 255);

		HUDS::FadeOverTime(Prest5[client], 200, 255, 255, 255, 255);

		HUDS::FadeOverTime(Prest6[client], 200, 255, 255, 255, 255);

		HUDS::FadeOverTime(Prest7[client], 200, 255, 255, 255, 255);

		HUDS::FadeOverTime(Prest8[client], 200, 255, 255, 255, 255);

		HUDS::FadeOverTime(Prest9[client], 200, 255, 255, 255, 255);

		HUDS::FadeOverTime(Prest10[client], 200, 255, 255, 255, 255);

		Prestige[client] = true;

	}

}



void StopPrestige(int client)

{

	HUDS::FadeOverTime(Prest0[client], 200, 255, 255, 255, 0);

	HUDS::FadeOverTime(Prest1[client], 200, 255, 255, 255, 0);

	HUDS::FadeOverTime(Prest2[client], 200, 255, 255, 255, 0);

	HUDS::FadeOverTime(Prest3[client], 200, 255, 255, 255, 0);

	HUDS::FadeOverTime(Prest4[client], 200, 255, 255, 255, 0);

	HUDS::FadeOverTime(Prest5[client], 200, 255, 255, 255, 0);

	HUDS::FadeOverTime(Prest6[client], 200, 255, 255, 255, 0);

	HUDS::FadeOverTime(Prest7[client], 200, 255, 255, 255, 0);

	HUDS::FadeOverTime(Prest8[client], 200, 255, 255, 255, 0);

	HUDS::FadeOverTime(Prest9[client], 200, 255, 255, 255, 0);

	HUDS::FadeOverTime(Prest10[client], 200, 255, 255, 255, 0);

	HUDS::ScaleOverTime(PrestBG[client], 400, 1, 50);

	sleep(400);

	HUDS::FadeOverTime(PrestBG[client], 1, 0, 0, 0, 0);

	Prestige[client] = false;

}



void UpdatePrest(int client, int scroll)

{

	if(scroll == 0)

	{

		int cord = (290 + (70 * scroll));

		HUDS::MoveOverTime(Prest0[client], 200, cord, 290);

		HUDS::ScaleOverTime(Prest0[client], 200, 70, 70);

		int cord1 = (220 + (70 * scroll));

		HUDS::MoveOverTime(Prest1[client], 200, cord1, 300);

		HUDS::ScaleOverTime(Prest1[client], 200, 50, 50);

		int cord2 = (150 + (70 * scroll));

		HUDS::MoveOverTime(Prest2[client], 200, cord2, 300);

		int cord3 = (80 + (70 * scroll));

		HUDS::MoveOverTime(Prest3[client], 200, cord3, 300);

		int cord4 = (10 + (70 * scroll));

		HUDS::MoveOverTime(Prest4[client], 200, cord4, 300);

		int cord5 = (-60 + (70 * scroll));

		HUDS::MoveOverTime(Prest5[client], 200, cord5, 300);

		int cord6 = (-130 + (70 * scroll));

		HUDS::MoveOverTime(Prest6[client], 200, cord6, 300);

		int cord7 = (-200 + (70 * scroll));

		HUDS::MoveOverTime(Prest7[client], 200, cord7, 300);

		int cord8 = (-270 + (70 * scroll));

		HUDS::MoveOverTime(Prest8[client], 200, cord8, 300);

		int cord9 = (-340 + (70 * scroll));

		HUDS::MoveOverTime(Prest9[client], 200, cord9, 300);

		int cord10 = (-410 + (70 * scroll));

		HUDS::MoveOverTime(Prest10[client], 200, cord10, 300);

		HUDS::ScaleOverTime(Prest10[client], 200, 50, 50);

	}

	if(scroll == 1)

	{

		int cord = (290 + (70 * scroll));

		HUDS::MoveOverTime(Prest0[client], 200, cord, 300);

		HUDS::ScaleOverTime(Prest0[client], 200, 50, 50);

		int cord1 = (220 + (70 * scroll));

		HUDS::MoveOverTime(Prest1[client], 200, cord1, 290);

		HUDS::ScaleOverTime(Prest1[client], 200, 70, 70);

		int cord2 = (150 + (70 * scroll));

		HUDS::MoveOverTime(Prest2[client], 200, cord2, 300);

		HUDS::ScaleOverTime(Prest2[client], 200, 50, 50);

		int cord3 = (80 + (70 * scroll));

		HUDS::MoveOverTime(Prest3[client], 200, cord3, 300);

		int cord4 = (10 + (70 * scroll));

		HUDS::MoveOverTime(Prest4[client], 200, cord4, 300);

		int cord5 = (-60 + (70 * scroll));

		HUDS::MoveOverTime(Prest5[client], 200, cord5, 300);

		int cord6 = (-130 + (70 * scroll));

		HUDS::MoveOverTime(Prest6[client], 200, cord6, 300);

		int cord7 = (-200 + (70 * scroll));

		HUDS::MoveOverTime(Prest7[client], 200, cord7, 300);

		int cord8 = (-270 + (70 * scroll));

		HUDS::MoveOverTime(Prest8[client], 200, cord8, 300);

		int cord9 = (-340 + (70 * scroll));

		HUDS::MoveOverTime(Prest9[client], 200, cord9, 300);

		int cord10 = (-410 + (70 * scroll));

		HUDS::MoveOverTime(Prest10[client], 200, cord10, 300);

	}

	if(scroll == 2)

	{

		int cord = (290 + (70 * scroll));

		HUDS::MoveOverTimeX(Prest0[client], 200, cord);

		int cord1 = (220 + (70 * scroll));

		HUDS::MoveOverTime(Prest1[client], 200, cord1, 300);

		HUDS::ScaleOverTime(Prest1[client], 200, 50, 50);

		int cord2 = (150 + (70 * scroll));

		HUDS::MoveOverTime(Prest2[client], 200, cord2, 290);

		HUDS::ScaleOverTime(Prest2[client], 200, 70, 70);

		int cord3 = (80 + (70 * scroll));

		HUDS::MoveOverTime(Prest3[client], 200, cord3, 300);

		HUDS::ScaleOverTime(Prest3[client], 200, 50, 50);

		int cord4 = (10 + (70 * scroll));

		HUDS::MoveOverTimeX(Prest4[client], 200, cord4);

		int cord5 = (-60 + (70 * scroll));

		HUDS::MoveOverTimeX(Prest5[client], 200, cord5);

		int cord6 = (-130 + (70 * scroll));

		HUDS::MoveOverTimeX(Prest6[client], 200, cord6);

		int cord7 = (-200 + (70 * scroll));

		HUDS::MoveOverTimeX(Prest7[client], 200, cord7);

		int cord8 = (-270 + (70 * scroll));

		HUDS::MoveOverTimeX(Prest8[client], 200, cord;

		int cord9 = (-340 + (70 * scroll));

		HUDS::MoveOverTimeX(Prest9[client], 200, cord9);

		int cord10 = (-410 + (70 * scroll));

		HUDS::MoveOverTimeX(Prest10[client], 200, cord10);

	}

	if(scroll == 3)

	{

		int cord = (290 + (70 * scroll));

		HUDS::MoveOverTimeX(Prest0[client], 200, cord);

		int cord1 = (220 + (70 * scroll));

		HUDS::MoveOverTimeX(Prest1[client], 200, cord1);

		int cord2 = (150 + (70 * scroll));

		HUDS::MoveOverTime(Prest2[client], 200, cord2, 300);

		HUDS::ScaleOverTime(Prest2[client], 200, 50, 50);

		int cord3 = (80 + (70 * scroll));

		HUDS::MoveOverTime(Prest3[client], 200, cord3, 290);

		HUDS::ScaleOverTime(Prest3[client], 200, 70, 70);

		int cord4 = (10 + (70 * scroll));

		HUDS::MoveOverTime(Prest4[client], 200, cord4, 300);

		HUDS::ScaleOverTime(Prest4[client], 200, 50, 50);

		int cord5 = (-60 + (70 * scroll));

		HUDS::MoveOverTimeX(Prest5[client], 200, cord5);

		int cord6 = (-130 + (70 * scroll));

		HUDS::MoveOverTimeX(Prest6[client], 200, cord6);

		int cord7 = (-200 + (70 * scroll));

		HUDS::MoveOverTimeX(Prest7[client], 200, cord7);

		int cord8 = (-270 + (70 * scroll));

		HUDS::MoveOverTimeX(Prest8[client], 200, cord;

		int cord9 = (-340 + (70 * scroll));

		HUDS::MoveOverTimeX(Prest9[client], 200, cord9);

		int cord10 = (-410 + (70 * scroll));

		HUDS::MoveOverTimeX(Prest10[client], 200, cord10);

	}

	if(scroll == 4)

	{

		int cord = (290 + (70 * scroll));

		HUDS::MoveOverTimeX(Prest0[client], 200, cord);	

		int cord1 = (220 + (70 * scroll));

		HUDS::MoveOverTimeX(Prest1[client], 200, cord1);

		int cord2 = (150 + (70 * scroll));

		HUDS::MoveOverTimeX(Prest2[client], 200, cord2);

		int cord3 = (80 + (70 * scroll));

		HUDS::MoveOverTime(Prest3[client], 200, cord3, 300);

		HUDS::ScaleOverTime(Prest3[client], 200, 50, 50);

		int cord4 = (10 + (70 * scroll));

		HUDS::MoveOverTime(Prest4[client], 200, cord4, 290);

		HUDS::ScaleOverTime(Prest4[client], 200, 70, 70);

		int cord5 = (-60 + (70 * scroll));

		HUDS::MoveOverTime(Prest5[client], 200, cord5, 300);

		HUDS::ScaleOverTime(Prest5[client], 200, 50, 50);

		int cord6 = (-130 + (70 * scroll));

		HUDS::MoveOverTimeX(Prest6[client], 200, cord6);

		int cord7 = (-200 + (70 * scroll));

		HUDS::MoveOverTimeX(Prest7[client], 200, cord7);

		int cord8 = (-270 + (70 * scroll));

		HUDS::MoveOverTimeX(Prest8[client], 200, cord;

		int cord9 = (-340 + (70 * scroll));

		HUDS::MoveOverTimeX(Prest9[client], 200, cord9);

		int cord10 = (-410 + (70 * scroll));

		HUDS::MoveOverTimeX(Prest10[client], 200, cord10);

	}

	if(scroll == 5)

	{

		int cord = (290 + (70 * scroll));

		HUDS::MoveOverTimeX(Prest0[client], 200, cord);

		int cord1 = (220 + (70 * scroll));

		HUDS::MoveOverTimeX(Prest1[client], 200, cord1);

		int cord2 = (150 + (70 * scroll));

		HUDS::MoveOverTimeX(Prest2[client], 200, cord2);

		int cord3 = (80 + (70 * scroll));

		HUDS::MoveOverTimeX(Prest3[client], 200, cord3);

		int cord4 = (10 + (70 * scroll));

		HUDS::MoveOverTime(Prest4[client], 200, cord4, 300);

		HUDS::ScaleOverTime(Prest4[client], 200, 50, 50);

		int cord5 = (-60 + (70 * scroll));

		HUDS::MoveOverTime(Prest5[client], 200, cord5, 290);

		HUDS::ScaleOverTime(Prest5[client], 200, 70, 70);

		int cord6 = (-130 + (70 * scroll));

		HUDS::MoveOverTime(Prest6[client], 200, cord6, 300);

		HUDS::ScaleOverTime(Prest6[client], 200, 50, 50);

		int cord7 = (-200 + (70 * scroll));

		HUDS::MoveOverTimeX(Prest7[client], 200, cord7);

		int cord8 = (-270 + (70 * scroll));

		HUDS::MoveOverTimeX(Prest8[client], 200, cord;

		int cord9 = (-340 + (70 * scroll));

		HUDS::MoveOverTimeX(Prest9[client], 200, cord9);

		int cord10 = (-410 + (70 * scroll));

		HUDS::MoveOverTimeX(Prest10[client], 200, cord10);

	}

	if(scroll == 6)

	{

		int cord = (290 + (70 * scroll));

		HUDS::MoveOverTimeX(Prest0[client], 200, cord);

		int cord1 = (220 + (70 * scroll));

		HUDS::MoveOverTimeX(Prest1[client], 200, cord1);

		int cord2 = (150 + (70 * scroll));

		HUDS::MoveOverTimeX(Prest2[client], 200, cord2);

		int cord3 = (80 + (70 * scroll));

		HUDS::MoveOverTimeX(Prest3[client], 200, cord3);

		int cord4 = (10 + (70 * scroll));

		HUDS::MoveOverTimeX(Prest4[client], 200, cord4);

		int cord5 = (-60 + (70 * scroll));

		HUDS::MoveOverTime(Prest5[client], 200, cord5, 300);

		HUDS::ScaleOverTime(Prest5[client], 200, 50, 50);

		int cord6 = (-130 + (70 * scroll));

		HUDS::MoveOverTime(Prest6[client], 200, cord6, 290);

		HUDS::ScaleOverTime(Prest6[client], 200, 70, 70);

		int cord7 = (-200 + (70 * scroll));

		HUDS::MoveOverTime(Prest7[client], 200, cord7, 300);

		HUDS::ScaleOverTime(Prest7[client], 200, 50, 50);

		int cord8 = (-270 + (70 * scroll));

		HUDS::MoveOverTimeX(Prest8[client], 200, cord;

		int cord9 = (-340 + (70 * scroll));

		HUDS::MoveOverTimeX(Prest9[client], 200, cord9);

		int cord10 = (-410 + (70 * scroll));

		HUDS::MoveOverTimeX(Prest10[client], 200, cord10);

	}

	if(scroll == 7)

	{

		int cord = (290 + (70 * scroll));

		HUDS::MoveOverTimeX(Prest0[client], 200, cord);

		int cord1 = (220 + (70 * scroll));

		HUDS::MoveOverTimeX(Prest1[client], 200, cord1);

		int cord2 = (150 + (70 * scroll));

		HUDS::MoveOverTimeX(Prest2[client], 200, cord2);

		int cord3 = (80 + (70 * scroll));

		HUDS::MoveOverTimeX(Prest3[client], 200, cord3);

		int cord4 = (10 + (70 * scroll));

		HUDS::MoveOverTimeX(Prest4[client], 200, cord4);

		int cord5 = (-60 + (70 * scroll));

		HUDS::MoveOverTimeX(Prest5[client], 200, cord5);

		int cord6 = (-130 + (70 * scroll));

		HUDS::MoveOverTime(Prest6[client], 200, cord6, 300);

		HUDS::ScaleOverTime(Prest6[client], 200, 50, 50);

		int cord7 = (-200 + (70 * scroll));

		HUDS::MoveOverTime(Prest7[client], 200, cord7, 290);

		HUDS::ScaleOverTime(Prest7[client], 200, 70, 70);

		int cord8 = (-270 + (70 * scroll));

		HUDS::MoveOverTime(Prest8[client], 200, cord8, 300);

		HUDS::ScaleOverTime(Prest8[client], 200, 50, 50);

		int cord9 = (-340 + (70 * scroll));

		HUDS::MoveOverTimeX(Prest9[client], 200, cord9);

		int cord10 = (-410 + (70 * scroll));

		HUDS::MoveOverTimeX(Prest10[client], 200, cord10);

	}

	if(scroll == 

	{

		int cord = (290 + (70 * scroll));

		HUDS::MoveOverTime(Prest0[client], 200, cord, 300);

		int cord1 = (220 + (70 * scroll));

		HUDS::MoveOverTime(Prest1[client], 200, cord1, 300);

		int cord2 = (150 + (70 * scroll));

		HUDS::MoveOverTime(Prest2[client], 200, cord2, 300);

		int cord3 = (80 + (70 * scroll));

		HUDS::MoveOverTime(Prest3[client], 200, cord3, 300);

		int cord4 = (10 + (70 * scroll));

		HUDS::MoveOverTime(Prest4[client], 200, cord4, 300);

		int cord5 = (-60 + (70 * scroll));

		HUDS::MoveOverTime(Prest5[client], 200, cord5, 300);

		int cord6 = (-130 + (70 * scroll));

		HUDS::MoveOverTime(Prest6[client], 200, cord6, 300);

		int cord7 = (-200 + (70 * scroll));

		HUDS::MoveOverTime(Prest7[client], 200, cord7, 300);

		HUDS::ScaleOverTime(Prest7[client], 200, 50, 50);

		int cord8 = (-270 + (70 * scroll));

		HUDS::MoveOverTime(Prest8[client], 200, cord8, 290);

		HUDS::ScaleOverTime(Prest8[client], 200, 70, 70);

		int cord9 = (-340 + (70 * scroll));

		HUDS::MoveOverTime(Prest9[client], 200, cord9, 300);

		HUDS::ScaleOverTime(Prest9[client], 200, 50, 50);

		int cord10 = (-410 + (70 * scroll));

		HUDS::MoveOverTime(Prest10[client], 200, cord10, 300);

	}

	if(scroll == 9)

	{

		int cord = (290 + (70 * scroll));

		HUDS::MoveOverTimeX(Prest0[client], 200, cord);

		int cord1 = (220 + (70 * scroll));

		HUDS::MoveOverTimeX(Prest1[client], 200, cord1);

		int cord2 = (150 + (70 * scroll));

		HUDS::MoveOverTimeX(Prest2[client], 200, cord2);

		int cord3 = (80 + (70 * scroll));

		HUDS::MoveOverTimeX(Prest3[client], 200, cord3);

		int cord4 = (10 + (70 * scroll));

		HUDS::MoveOverTimeX(Prest4[client], 200, cord4);

		int cord5 = (-60 + (70 * scroll));

		HUDS::MoveOverTimeX(Prest5[client], 200, cord5);

		int cord6 = (-130 + (70 * scroll));

		HUDS::MoveOverTimeX(Prest6[client], 200, cord6);

		int cord7 = (-200 + (70 * scroll));

		HUDS::MoveOverTimeX(Prest7[client], 200, cord7);

		int cord8 = (-270 + (70 * scroll));

		HUDS::MoveOverTime(Prest8[client], 200, cord8, 300);

		HUDS::ScaleOverTime(Prest8[client], 200, 50, 50);

		int cord9 = (-340 + (70 * scroll));

		HUDS::MoveOverTime(Prest9[client], 200, cord9, 290);

		HUDS::ScaleOverTime(Prest9[client], 200, 70, 70);

		int cord10 = (-410 + (70 * scroll));

		HUDS::MoveOverTime(Prest10[client], 200, cord10, 300);

		HUDS::ScaleOverTime(Prest10[client], 200, 50, 50);

	}

	if(scroll == 10)

	{

		int cord = (290 + (70 * scroll));

		HUDS::MoveOverTime(Prest0[client], 200, cord, 300);

		HUDS::ScaleOverTime(Prest0[client], 200, 50, 50);

		int cord1 = (220 + (70 * scroll));

		HUDS::MoveOverTimeX(Prest1[client], 200, cord1);

		int cord2 = (150 + (70 * scroll));

		HUDS::MoveOverTimeX(Prest2[client], 200, cord2);

		int cord3 = (80 + (70 * scroll));

		HUDS::MoveOverTimeX(Prest3[client], 200, cord3);

		int cord4 = (10 + (70 * scroll));

		HUDS::MoveOverTimeX(Prest4[client], 200, cord4);

		int cord5 = (-60 + (70 * scroll));

		HUDS::MoveOverTimeX(Prest5[client], 200, cord5);

		int cord6 = (-130 + (70 * scroll));

		HUDS::MoveOverTimeX(Prest6[client], 200, cord6);

		int cord7 = (-200 + (70 * scroll));

		HUDS::MoveOverTimeX(Prest7[client], 200, cord7);

		int cord8 = (-270 + (70 * scroll));

		HUDS::MoveOverTimeX(Prest8[client], 200, cord;

		int cord9 = (-340 + (70 * scroll));

		HUDS::MoveOverTime(Prest9[client], 200, cord9, 300);

		HUDS::ScaleOverTime(Prest9[client], 200, 50, 50);

		int cord10 = (-410 + (70 * scroll));

		HUDS::MoveOverTime(Prest10[client], 200, cord10, 290);

		HUDS::ScaleOverTime(Prest10[client], 200, 70, 70);

	}

}



if(Buttons:etectButtonDPAD(i, Buttons::Left) && Prestige[i])//put this on a loop 

						{

							PrestigeNumber[i]++;

							if (PrestigeNumber[i] > 11)

							{

								PrestigeNumber[i] = 0;

							}

							UpdatePrest(i, PrestigeNumber[i]);

							sleep(50);

						}

						if(Buttons:etectButtonDPAD(i, Buttons::Right) && !MenuOpen[i] && Prestige[i])

						{

							PrestigeNumber[i]--;

							if (PrestigeNumber[i] < 0)

							{

								PrestigeNumber[i] = 11;

							}

							UpdatePrest(i, PrestigeNumber[i]);

							sleep(50);

						}

						if(Buttons:etectButton(i, Buttons::X) && !MenuOpen[i] && Prestige[i])

						{

							StopPrestige(i);//add if(scroll == 0) etc to add prestiges to be set 

					         }

Save/Load teleport

Save location

    

float* Saved[18];

Saved[client] = Functions::getPlayerPosition(client);

SV_GameSendServerCommand(client, "< \"Position [^2Saved^7]\"");

Load location

    

DataFunctions::WriteFloat(0x1780F50 + (client * 0x580, Saved[client], 3);

SV_GameSendServerCommand(client, "< \"Position [^2Loaded^7]\"");

On player died

    

bool OnPlayerDie(int client)

{

      if (DataFunctions::ReadInt32(G_Client(client, 0x55D0)) == 1)

                return true;

      else return false;

}

[/spoiler]

On player spawn

    

bool OnPlayerSpawn(int client)

{

      if (OnPlayerDie(client))

                if (DataFunctions::ReadInt32(G_Client(client, 0x55D0)) == 0)

                    return true;

      else return false;

}

[/spoiler]

G_Client

    

int G_Client(int client, int Mod = 0x00)

{

        return 0x1780F28 + (0x5808 * client) + Mod;

}

[/spoiler]

G_Entity

    

int G_Entity(int client, int Mod = 0x00)

{

	return 0x16B9F20 + (0x31C * client) + Mod;

}

[/spoiler]

Freeze Client

    

void FreezeClient(int clientIndex, int FreezeType)

{

         DataFunctions::WriteInt32(Offsets::getPlayerstate(clientIndex, Offsets::ClientFreeze), FreezeType);

}

Get Number Of Players

    

int GetNumPlayers()

    {

        int num = 0;

        for (int i = 0; i < 17; i++)

        {

            if (DataFunctions::ReadInt(G_Client(i), 1) != 0)

            {

                num++;

            }

        }

        return num;

    }

In game

    

bool InGame()

{

        if (*(char*)Offsets::cl_ingame != 1)

		return false;

	return true;

}

SV_GameSendServerCommand

    

void SV_GameSendServerCommand(int Client, char* Command)

{

	opd_s SV1 = { 0x34A1DC, TOC };

	void(*SVGSSC)(int client, int type, char* cmd) = (void(*)(int, int, char*))&SV1;

	SVGSSC(Client, 0, Command);

}

Godmode

    

void GodMode(int Client)

{

if (*(char*)0x01780f43 == 4)

{

*(char*)(0x01780f43 + 0x5808 * Client) = 0x05;

}

else if (*(char*)0x01780f43 == 5)

{

*(char*)(0x01780f43 + 0x5808 * Client) = 0x04;

}

}

UnlimitedScorestreaks

    

void UnlimitedScorestreaks(int Client) //Just set in a loop like (; { UnlimitedScorestreaks(0); }

{

for (;

{

*(char*)(G_Client(Client) + 0x433) = 0x01;

*(char*)(G_Client(Client) + 0x437) = 0x01;

*(char*)(G_Client(Client) + 0x42F) = 0x01;

}

}

[/spoiler]

Get view angles

    

float floatArray[100];

float* ReadFloat(int address, int length)

{

for (int i = 0; i < length; i++)

{

floatArray[i] = *(float*)(address + (i * 0x04));

}

return floatArray;

}



float* GetViewAngles(int Client)

{

return ReadFloat((G_Client(Client) + 0x56BC), 3);

}

[/spoiler]

client Names

    

char* ReadString(int address)

  {

   memset(&returnRead[0], 0, sizeof(returnRead));

   int strlength = 100;

   char* StrBytes = ReadBytes(address, strlength);

   for (int i = 0; i < strlength; i++)

   {

    if (StrBytes[i] != 0x00)

     returnRead[i] = StrBytes[i];

    else

     break;

   }

   return returnRead;

  }



char* GetClientName(int Client)

{

char* Names[18];

Names[Client] = ReadString((G_Client(Client) + 0x5544));

if (Names[Client] == "")

{ Names[Client] = "Not Connected"; }

return Names[Client];

}

[/spoiler]

Math functions Smile

    

//credits to bitwise

	double cos(double x)

	{

		double t = -x*x / 2;

		double sum = 1 + t;

		for (int i = 2; i<20; ++i)

		{

			t *= -x*x / (2 * i*(2 * i - 1));

			sum += t;

		}

		return sum;

	}

	double sin(double x)

	{

		double term = x;

		double sum = x;

		for(int n = 1; n<10; ++n)

		{

		term *= x*x / (2 * n * (2 * n + 1));

		sum += n % 2 ? -term : term;

		}

	return sum;

	}



inline Vector3 Vector3::AnglesToForward ( )

{

        Vector3 vec;

        vec.x = (cos(x*(3.14159265358979323846*2 / 360))*cos(y*(3.14159265358979323846*2 / 360)));

        vec.y = (cos(x*(3.14159265358979323846*2 / 360))*sin(y*(3.14159265358979323846*2 / 360)));

        vec.z = -sin(x*(3.14159265358979323846*2 / 360));

        return vec;

}

 

inline Vector3 Vector3::VectorToAngles ( )

{

        Vector3 vec3;

        float yaw, pitch;

        if(!x && !y)

        {

                yaw = 0;

                if(z > 0) pitch = 90; else pitch = 270;

        }

        else

        {

                yaw = atan2(y,z)*180/3.14159265358979323846;

                if(yaw<0)yaw+=360;

                pitch= atan2(z,sqrt(x*x+y*y)) * 180/3.14159265358979323846;

                if(pitch<0)pitch+=360;

        }

        vec3.x = pitch;

        vec3.y = yaw;

        vec3.z = 0;

        return vec3;

}

Cbuf_AddText

    

void Cbuf_AddText(char* Command)

	{

		opd_s CB1 = {0x313E88, TOC };

		void(*CAT)(int type,char* cmd) = (void(*)(int,char*))&CB1;

		CAT(0, Command);

	}

You must login or register to view this content.

Last edited by OLDSCHOOLMODZHD ; 08-03-2014 at 10:04 PM. Reason: updated

The following 29 users say thank you to OLDSCHOOLMODZHD for this useful post:

/SneakerStreet/, #extortion_, RawDog2002, Algebra, ALI ALHILFI, Ariel R., BlueSkyMods, BoatyMcBoatFace, Dan Dactyl, FusionIsDaName, Geo, iRnZ, JackMods-, Joren, kainer wainer, kiwi_modz, LaRip8, MegaMister, Notorious, oCoyeks, oStankyModz, PS3 ITA DEX <3, Smooth, Swaqq, Taylors Bish, TheModedHacker, Venorai, xREVISIONxMoDz, zRayz-

The following user groaned OLDSCHOOLMODZHD for this awful post:

Not Rage

07-27-2014, 05:54 PM #2

Chris

Former Staff

5,476

Posts

43,042

Reputation

163

Credits

Former Staff

Dec 2011

NextGenUpdate

Nice. I sent you a Private Message, would you mind taking a minute to read it? Smile

07-27-2014, 05:59 PM #3

Smooth

< ^ > < ^ >

1,109

Posts

8,711

Reputation

29

Credits

Member

Oct 2013

NextGenUpdate

Originally posted by OLDSCHOOLMODZHD

If you want me to add anything just post it below Happy

hopefully more people will be making sprx and c++ tools Smile

Prestige scroller bar

    

int PrestigeNumber[18];

bool storeP[18];

bool Prestige[18];

//huds

int PrestBG[18];

int Prest0[18];

int Prest1[18];

int Prest2[18];

int Prest3[18];

int Prest4[18];

int Prest5[18];

int Prest6[18];

int Prest7[18];

int Prest8[18];

int Prest9[18];

int Prest10[18];

int Prest11[18];

int Prest12[18];

int Prest13[18];

int Prest14[18];

int Prest15[18];

int Prest16[18];



void RunPrestige(int client)

{

	if(!storeP[client])

	{

		PrestBG[client] = HUDS::SetShader(client, "white", 1, 50, -110, 300, 0, 0, 0, 0, 0);

		Prest0[client] = HUDS::SetShader(client, "rank_com", 70, 70, 290, 290, 0, 255, 255, 255, 0);

		Prest1[client] = HUDS::SetShader(client, "rank_prestige01", 50, 50, 220, 300, 0, 255, 255, 255, 0);

		Prest2[client] = HUDS::SetShader(client, "rank_prestige02", 50, 50, 150, 300, 0, 255, 255, 255, 0);

		Prest3[client] = HUDS::SetShader(client, "rank_prestige03", 50, 50, 80, 300, 0, 255, 255, 255, 0);

		Prest4[client] = HUDS::SetShader(client, "rank_prestige04", 50, 50, 10, 300, 0, 255, 255, 255, 0);

		Prest5[client] = HUDS::SetShader(client, "rank_prestige05", 50, 50, -60, 300, 0, 255, 255, 255, 0);

		Prest6[client] = HUDS::SetShader(client, "rank_prestige06", 50, 50, -130, 300, 0, 255, 255, 255, 0);

		Prest7[client] = HUDS::SetShader(client, "rank_prestige07", 50, 50, -200, 300, 0, 255, 255, 255, 0);

		Prest8[client] = HUDS::SetShader(client, "rank_prestige08", 50, 50, -270, 300, 0, 255, 255, 255, 0);

		Prest9[client] = HUDS::SetShader(client, "rank_prestige09", 50, 50, -340, 300, 0, 255, 255, 255, 0);

		Prest10[client] = HUDS::SetShader(client, "rank_prestige10", 50, 50, -410, 300, 0, 255, 255, 255, 0);



		HUDS::FadeOverTime(PrestBG[client], 1, ShaderR[client], ShaderG[client], ShaderB[client], 150);

		HUDS::ScaleOverTime(PrestBG[client], 400, 890, 50);

		HUDS::FadeOverTime(Prest0[client], 200, 255, 255, 255, 255);

		HUDS::FadeOverTime(Prest1[client], 200, 255, 255, 255, 255);

		HUDS::FadeOverTime(Prest2[client], 200, 255, 255, 255, 255);

		HUDS::FadeOverTime(Prest3[client], 200, 255, 255, 255, 255);

		HUDS::FadeOverTime(Prest4[client], 200, 255, 255, 255, 255);

		HUDS::FadeOverTime(Prest5[client], 200, 255, 255, 255, 255);

	        HUDS::FadeOverTime(Prest6[client], 200, 255, 255, 255, 255);

		HUDS::FadeOverTime(Prest7[client], 200, 255, 255, 255, 255);

                HUDS::FadeOverTime(Prest8[client], 200, 255, 255, 255, 255);

		HUDS::FadeOverTime(Prest9[client], 200, 255, 255, 255, 255);

	        HUDS::FadeOverTime(Prest10[client], 200, 255, 255, 255, 255);

		P restige[client] = true;

		storeP[client] = true;

	}

	else

	{

		HUDS::FadeOverTime(PrestBG[client], 1, 0, 0, 0, 150);

		HUDS::ScaleOverTime(PrestBG[client], 400, 890, 50);

		HUDS::FadeOverTime(Prest0[client], 200, 255, 255, 255, 255);

		HUDS::FadeOverTime(Prest1[client], 200, 255, 255, 255, 255);

		HUDS::FadeOverTime(Prest2[client], 200, 255, 255, 255, 255);

		HUDS::FadeOverTime(Prest3[client], 200, 255, 255, 255, 255);

		HUDS::FadeOverTime(Prest4[client], 200, 255, 255, 255, 255);

		HUDS::FadeOverTime(Prest5[client], 200, 255, 255, 255, 255);

		HUDS::FadeOverTime(Prest6[client], 200, 255, 255, 255, 255);

		HUDS::FadeOverTime(Prest7[client], 200, 255, 255, 255, 255);

		HUDS::FadeOverTime(Prest8[client], 200, 255, 255, 255, 255);

		HUDS::FadeOverTime(Prest9[client], 200, 255, 255, 255, 255);

		HUDS::FadeOverTime(Prest10[client], 200, 255, 255, 255, 255);

		Prestige[client] = true;

	}

}



void StopPrestige(int client)

{

	HUDS::FadeOverTime(Prest0[client], 200, 255, 255, 255, 0);

	HUDS::FadeOverTime(Prest1[client], 200, 255, 255, 255, 0);

	HUDS::FadeOverTime(Prest2[client], 200, 255, 255, 255, 0);

	HUDS::FadeOverTime(Prest3[client], 200, 255, 255, 255, 0);

	HUDS::FadeOverTime(Prest4[client], 200, 255, 255, 255, 0);

	HUDS::FadeOverTime(Prest5[client], 200, 255, 255, 255, 0);

	HUDS::FadeOverTime(Prest6[client], 200, 255, 255, 255, 0);

	HUDS::FadeOverTime(Prest7[client], 200, 255, 255, 255, 0);

	HUDS::FadeOverTime(Prest8[client], 200, 255, 255, 255, 0);

	HUDS::FadeOverTime(Prest9[client], 200, 255, 255, 255, 0);

	HUDS::FadeOverTime(Prest10[client], 200, 255, 255, 255, 0);

	HUDS::ScaleOverTime(PrestBG[client], 400, 1, 50);

	sleep(400);

	HUDS::FadeOverTime(PrestBG[client], 1, 0, 0, 0, 0);

	Prestige[client] = false;

}



void UpdatePrest(int client, int scroll)

{

	if(scroll == 0)

	{

		int cord = (290 + (70 * scroll));

		HUDS::MoveOverTime(Prest0[client], 200, cord, 290);

		HUDS::ScaleOverTime(Prest0[client], 200, 70, 70);

		int cord1 = (220 + (70 * scroll));

		HUDS::MoveOverTime(Prest1[client], 200, cord1, 300);

		HUDS::ScaleOverTime(Prest1[client], 200, 50, 50);

		int cord2 = (150 + (70 * scroll));

		HUDS::MoveOverTime(Prest2[client], 200, cord2, 300);

		int cord3 = (80 + (70 * scroll));

		HUDS::MoveOverTime(Prest3[client], 200, cord3, 300);

		int cord4 = (10 + (70 * scroll));

		HUDS::MoveOverTime(Prest4[client], 200, cord4, 300);

		int cord5 = (-60 + (70 * scroll));

		HUDS::MoveOverTime(Prest5[client], 200, cord5, 300);

		int cord6 = (-130 + (70 * scroll));

		HUDS::MoveOverTime(Prest6[client], 200, cord6, 300);

		int cord7 = (-200 + (70 * scroll));

		HUDS::MoveOverTime(Prest7[client], 200, cord7, 300);

		int cord8 = (-270 + (70 * scroll));

		HUDS::MoveOverTime(Prest8[client], 200, cord8, 300);

		int cord9 = (-340 + (70 * scroll));

		HUDS::MoveOverTime(Prest9[client], 200, cord9, 300);

		int cord10 = (-410 + (70 * scroll));

		HUDS::MoveOverTime(Prest10[client], 200, cord10, 300);

		HUDS::ScaleOverTime(Prest10[client], 200, 50, 50);

	}

	if(scroll == 1)

	{

		int cord = (290 + (70 * scroll));

		HUDS::MoveOverTime(Prest0[client], 200, cord, 300);

		HUDS::ScaleOverTime(Prest0[client], 200, 50, 50);

		int cord1 = (220 + (70 * scroll));

		HUDS::MoveOverTime(Prest1[client], 200, cord1, 290);

		HUDS::ScaleOverTime(Prest1[client], 200, 70, 70);

		int cord2 = (150 + (70 * scroll));

		HUDS::MoveOverTime(Prest2[client], 200, cord2, 300);

		HUDS::ScaleOverTime(Prest2[client], 200, 50, 50);

		int cord3 = (80 + (70 * scroll));

		HUDS::MoveOverTime(Prest3[client], 200, cord3, 300);

		int cord4 = (10 + (70 * scroll));

		HUDS::MoveOverTime(Prest4[client], 200, cord4, 300);

		int cord5 = (-60 + (70 * scroll));

		HUDS::MoveOverTime(Prest5[client], 200, cord5, 300);

		int cord6 = (-130 + (70 * scroll));

		HUDS::MoveOverTime(Prest6[client], 200, cord6, 300);

		int cord7 = (-200 + (70 * scroll));

		HUDS::MoveOverTime(Prest7[client], 200, cord7, 300);

		int cord8 = (-270 + (70 * scroll));

		HUDS::MoveOverTime(Prest8[client], 200, cord8, 300);

		int cord9 = (-340 + (70 * scroll));

		HUDS::MoveOverTime(Prest9[client], 200, cord9, 300);

		int cord10 = (-410 + (70 * scroll));

		HUDS::MoveOverTime(Prest10[client], 200, cord10, 300);

	}

	if(scroll == 2)

	{

		int cord = (290 + (70 * scroll));

		HUDS::MoveOverTimeX(Prest0[client], 200, cord);

		int cord1 = (220 + (70 * scroll));

		HUDS::MoveOverTime(Prest1[client], 200, cord1, 300);

		HUDS::ScaleOverTime(Prest1[client], 200, 50, 50);

		int cord2 = (150 + (70 * scroll));

		HUDS::MoveOverTime(Prest2[client], 200, cord2, 290);

		HUDS::ScaleOverTime(Prest2[client], 200, 70, 70);

		int cord3 = (80 + (70 * scroll));

		HUDS::MoveOverTime(Prest3[client], 200, cord3, 300);

		HUDS::ScaleOverTime(Prest3[client], 200, 50, 50);

		int cord4 = (10 + (70 * scroll));

		HUDS::MoveOverTimeX(Prest4[client], 200, cord4);

		int cord5 = (-60 + (70 * scroll));

		HUDS::MoveOverTimeX(Prest5[client], 200, cord5);

		int cord6 = (-130 + (70 * scroll));

		HUDS::MoveOverTimeX(Prest6[client], 200, cord6);

		int cord7 = (-200 + (70 * scroll));

		HUDS::MoveOverTimeX(Prest7[client], 200, cord7);

		int cord8 = (-270 + (70 * scroll));

		HUDS::MoveOverTimeX(Prest8[client], 200, cord;

		int cord9 = (-340 + (70 * scroll));

		HUDS::MoveOverTimeX(Prest9[client], 200, cord9);

		int cord10 = (-410 + (70 * scroll));

		HUDS::MoveOverTimeX(Prest10[client], 200, cord10);

	}

	if(scroll == 3)

	{

		int cord = (290 + (70 * scroll));

		HUDS::MoveOverTimeX(Prest0[client], 200, cord);

		int cord1 = (220 + (70 * scroll));

		HUDS::MoveOverTimeX(Prest1[client], 200, cord1);

		int cord2 = (150 + (70 * scroll));

		HUDS::MoveOverTime(Prest2[client], 200, cord2, 300);

		HUDS::ScaleOverTime(Prest2[client], 200, 50, 50);

		int cord3 = (80 + (70 * scroll));

		HUDS::MoveOverTime(Prest3[client], 200, cord3, 290);

		HUDS::ScaleOverTime(Prest3[client], 200, 70, 70);

		int cord4 = (10 + (70 * scroll));

		HUDS::MoveOverTime(Prest4[client], 200, cord4, 300);

		HUDS::ScaleOverTime(Prest4[client], 200, 50, 50);

		int cord5 = (-60 + (70 * scroll));

		HUDS::MoveOverTimeX(Prest5[client], 200, cord5);

		int cord6 = (-130 + (70 * scroll));

		HUDS::MoveOverTimeX(Prest6[client], 200, cord6);

		int cord7 = (-200 + (70 * scroll));

		HUDS::MoveOverTimeX(Prest7[client], 200, cord7);

		int cord8 = (-270 + (70 * scroll));

		HUDS::MoveOverTimeX(Prest8[client], 200, cord;

		int cord9 = (-340 + (70 * scroll));

		HUDS::MoveOverTimeX(Prest9[client], 200, cord9);

		int cord10 = (-410 + (70 * scroll));

		HUDS::MoveOverTimeX(Prest10[client], 200, cord10);

	}

	if(scroll == 4)

	{

		int cord = (290 + (70 * scroll));

		HUDS::MoveOverTimeX(Prest0[client], 200, cord);	

		int cord1 = (220 + (70 * scroll));

		HUDS::MoveOverTimeX(Prest1[client], 200, cord1);

		int cord2 = (150 + (70 * scroll));

		HUDS::MoveOverTimeX(Prest2[client], 200, cord2);

		int cord3 = (80 + (70 * scroll));

		HUDS::MoveOverTime(Prest3[client], 200, cord3, 300);

		HUDS::ScaleOverTime(Prest3[client], 200, 50, 50);

		int cord4 = (10 + (70 * scroll));

		HUDS::MoveOverTime(Prest4[client], 200, cord4, 290);

		HUDS::ScaleOverTime(Prest4[client], 200, 70, 70);

		int cord5 = (-60 + (70 * scroll));

		HUDS::MoveOverTime(Prest5[client], 200, cord5, 300);

		HUDS::ScaleOverTime(Prest5[client], 200, 50, 50);

		int cord6 = (-130 + (70 * scroll));

		HUDS::MoveOverTimeX(Prest6[client], 200, cord6);

		int cord7 = (-200 + (70 * scroll));

		HUDS::MoveOverTimeX(Prest7[client], 200, cord7);

		int cord8 = (-270 + (70 * scroll));

		HUDS::MoveOverTimeX(Prest8[client], 200, cord;

		int cord9 = (-340 + (70 * scroll));

		HUDS::MoveOverTimeX(Prest9[client], 200, cord9);

		int cord10 = (-410 + (70 * scroll));

		HUDS::MoveOverTimeX(Prest10[client], 200, cord10);

	}

	if(scroll == 5)

	{

		int cord = (290 + (70 * scroll));

		HUDS::MoveOverTimeX(Prest0[client], 200, cord);

		int cord1 = (220 + (70 * scroll));

		HUDS::MoveOverTimeX(Prest1[client], 200, cord1);

		int cord2 = (150 + (70 * scroll));

		HUDS::MoveOverTimeX(Prest2[client], 200, cord2);

		int cord3 = (80 + (70 * scroll));

		HUDS::MoveOverTimeX(Prest3[client], 200, cord3);

		int cord4 = (10 + (70 * scroll));

		HUDS::MoveOverTime(Prest4[client], 200, cord4, 300);

		HUDS::ScaleOverTime(Prest4[client], 200, 50, 50);

		int cord5 = (-60 + (70 * scroll));

		HUDS::MoveOverTime(Prest5[client], 200, cord5, 290);

		HUDS::ScaleOverTime(Prest5[client], 200, 70, 70);

		int cord6 = (-130 + (70 * scroll));

		HUDS::MoveOverTime(Prest6[client], 200, cord6, 300);

		HUDS::ScaleOverTime(Prest6[client], 200, 50, 50);

		int cord7 = (-200 + (70 * scroll));

		HUDS::MoveOverTimeX(Prest7[client], 200, cord7);

		int cord8 = (-270 + (70 * scroll));

		HUDS::MoveOverTimeX(Prest8[client], 200, cord;

		int cord9 = (-340 + (70 * scroll));

		HUDS::MoveOverTimeX(Prest9[client], 200, cord9);

		int cord10 = (-410 + (70 * scroll));

		HUDS::MoveOverTimeX(Prest10[client], 200, cord10);

	}

	if(scroll == 6)

	{

		int cord = (290 + (70 * scroll));

		HUDS::MoveOverTimeX(Prest0[client], 200, cord);

		int cord1 = (220 + (70 * scroll));

		HUDS::MoveOverTimeX(Prest1[client], 200, cord1);

		int cord2 = (150 + (70 * scroll));

		HUDS::MoveOverTimeX(Prest2[client], 200, cord2);

		int cord3 = (80 + (70 * scroll));

		HUDS::MoveOverTimeX(Prest3[client], 200, cord3);

		int cord4 = (10 + (70 * scroll));

		HUDS::MoveOverTimeX(Prest4[client], 200, cord4);

		int cord5 = (-60 + (70 * scroll));

		HUDS::MoveOverTime(Prest5[client], 200, cord5, 300);

		HUDS::ScaleOverTime(Prest5[client], 200, 50, 50);

		int cord6 = (-130 + (70 * scroll));

		HUDS::MoveOverTime(Prest6[client], 200, cord6, 290);

		HUDS::ScaleOverTime(Prest6[client], 200, 70, 70);

		int cord7 = (-200 + (70 * scroll));

		HUDS::MoveOverTime(Prest7[client], 200, cord7, 300);

		HUDS::ScaleOverTime(Prest7[client], 200, 50, 50);

		int cord8 = (-270 + (70 * scroll));

		HUDS::MoveOverTimeX(Prest8[client], 200, cord;

		int cord9 = (-340 + (70 * scroll));

		HUDS::MoveOverTimeX(Prest9[client], 200, cord9);

		int cord10 = (-410 + (70 * scroll));

		HUDS::MoveOverTimeX(Prest10[client], 200, cord10);

	}

	if(scroll == 7)

	{

		int cord = (290 + (70 * scroll));

		HUDS::MoveOverTimeX(Prest0[client], 200, cord);

		int cord1 = (220 + (70 * scroll));

		HUDS::MoveOverTimeX(Prest1[client], 200, cord1);

		int cord2 = (150 + (70 * scroll));

		HUDS::MoveOverTimeX(Prest2[client], 200, cord2);

		int cord3 = (80 + (70 * scroll));

		HUDS::MoveOverTimeX(Prest3[client], 200, cord3);

		int cord4 = (10 + (70 * scroll));

		HUDS::MoveOverTimeX(Prest4[client], 200, cord4);

		int cord5 = (-60 + (70 * scroll));

		HUDS::MoveOverTimeX(Prest5[client], 200, cord5);

		int cord6 = (-130 + (70 * scroll));

		HUDS::MoveOverTime(Prest6[client], 200, cord6, 300);

		HUDS::ScaleOverTime(Prest6[client], 200, 50, 50);

		int cord7 = (-200 + (70 * scroll));

		HUDS::MoveOverTime(Prest7[client], 200, cord7, 290);

		HUDS::ScaleOverTime(Prest7[client], 200, 70, 70);

		int cord8 = (-270 + (70 * scroll));

		HUDS::MoveOverTime(Prest8[client], 200, cord8, 300);

		HUDS::ScaleOverTime(Prest8[client], 200, 50, 50);

		int cord9 = (-340 + (70 * scroll));

		HUDS::MoveOverTimeX(Prest9[client], 200, cord9);

		int cord10 = (-410 + (70 * scroll));

		HUDS::MoveOverTimeX(Prest10[client], 200, cord10);

	}

	if(scroll == 

	{

		int cord = (290 + (70 * scroll));

		HUDS::MoveOverTime(Prest0[client], 200, cord, 300);

		int cord1 = (220 + (70 * scroll));

		HUDS::MoveOverTime(Prest1[client], 200, cord1, 300);

		int cord2 = (150 + (70 * scroll));

		HUDS::MoveOverTime(Prest2[client], 200, cord2, 300);

		int cord3 = (80 + (70 * scroll));

		HUDS::MoveOverTime(Prest3[client], 200, cord3, 300);

		int cord4 = (10 + (70 * scroll));

		HUDS::MoveOverTime(Prest4[client], 200, cord4, 300);

		int cord5 = (-60 + (70 * scroll));

		HUDS::MoveOverTime(Prest5[client], 200, cord5, 300);

		int cord6 = (-130 + (70 * scroll));

		HUDS::MoveOverTime(Prest6[client], 200, cord6, 300);

		int cord7 = (-200 + (70 * scroll));

		HUDS::MoveOverTime(Prest7[client], 200, cord7, 300);

		HUDS::ScaleOverTime(Prest7[client], 200, 50, 50);

		int cord8 = (-270 + (70 * scroll));

		HUDS::MoveOverTime(Prest8[client], 200, cord8, 290);

		HUDS::ScaleOverTime(Prest8[client], 200, 70, 70);

		int cord9 = (-340 + (70 * scroll));

		HUDS::MoveOverTime(Prest9[client], 200, cord9, 300);

		HUDS::ScaleOverTime(Prest9[client], 200, 50, 50);

		int cord10 = (-410 + (70 * scroll));

		HUDS::MoveOverTime(Prest10[client], 200, cord10, 300);

	}

	if(scroll == 9)

	{

		int cord = (290 + (70 * scroll));

		HUDS::MoveOverTimeX(Prest0[client], 200, cord);

		int cord1 = (220 + (70 * scroll));

		HUDS::MoveOverTimeX(Prest1[client], 200, cord1);

		int cord2 = (150 + (70 * scroll));

		HUDS::MoveOverTimeX(Prest2[client], 200, cord2);

		int cord3 = (80 + (70 * scroll));

		HUDS::MoveOverTimeX(Prest3[client], 200, cord3);

		int cord4 = (10 + (70 * scroll));

		HUDS::MoveOverTimeX(Prest4[client], 200, cord4);

		int cord5 = (-60 + (70 * scroll));

		HUDS::MoveOverTimeX(Prest5[client], 200, cord5);

		int cord6 = (-130 + (70 * scroll));

		HUDS::MoveOverTimeX(Prest6[client], 200, cord6);

		int cord7 = (-200 + (70 * scroll));

		HUDS::MoveOverTimeX(Prest7[client], 200, cord7);

		int cord8 = (-270 + (70 * scroll));

		HUDS::MoveOverTime(Prest8[client], 200, cord8, 300);

		HUDS::ScaleOverTime(Prest8[client], 200, 50, 50);

		int cord9 = (-340 + (70 * scroll));

		HUDS::MoveOverTime(Prest9[client], 200, cord9, 290);

		HUDS::ScaleOverTime(Prest9[client], 200, 70, 70);

		int cord10 = (-410 + (70 * scroll));

		HUDS::MoveOverTime(Prest10[client], 200, cord10, 300);

		HUDS::ScaleOverTime(Prest10[client], 200, 50, 50);

	}

	if(scroll == 10)

	{

		int cord = (290 + (70 * scroll));

		HUDS::MoveOverTime(Prest0[client], 200, cord, 300);

		HUDS::ScaleOverTime(Prest0[client], 200, 50, 50);

		int cord1 = (220 + (70 * scroll));

		HUDS::MoveOverTimeX(Prest1[client], 200, cord1);

		int cord2 = (150 + (70 * scroll));

		HUDS::MoveOverTimeX(Prest2[client], 200, cord2);

		int cord3 = (80 + (70 * scroll));

		HUDS::MoveOverTimeX(Prest3[client], 200, cord3);

		int cord4 = (10 + (70 * scroll));

		HUDS::MoveOverTimeX(Prest4[client], 200, cord4);

		int cord5 = (-60 + (70 * scroll));

		HUDS::MoveOverTimeX(Prest5[client], 200, cord5);

		int cord6 = (-130 + (70 * scroll));

		HUDS::MoveOverTimeX(Prest6[client], 200, cord6);

		int cord7 = (-200 + (70 * scroll));

		HUDS::MoveOverTimeX(Prest7[client], 200, cord7);

		int cord8 = (-270 + (70 * scroll));

		HUDS::MoveOverTimeX(Prest8[client], 200, cord;

		int cord9 = (-340 + (70 * scroll));

		HUDS::MoveOverTime(Prest9[client], 200, cord9, 300);

		HUDS::ScaleOverTime(Prest9[client], 200, 50, 50);

		int cord10 = (-410 + (70 * scroll));

		HUDS::MoveOverTime(Prest10[client], 200, cord10, 290);

		HUDS::ScaleOverTime(Prest10[client], 200, 70, 70);

	}

}



if(Buttons:etectButtonDPAD(i, Buttons::Left) && Prestige[i])

						{

							PrestigeNumber[i]++;

							if (PrestigeNumber[i] > 11)

							{

								PrestigeNumber[i] = 0;

							}

							UpdatePrest(i, PrestigeNumber[i]);

							sleep(50);

						}

						if(Buttons:etectButtonDPAD(i, Buttons::Right) && !MenuOpen[i] && Prestige[i])

						{

							PrestigeNumber[i]--;

							if (PrestigeNumber[i] < 0)

							{

								PrestigeNumber[i] = 11;

							}

							UpdatePrest(i, PrestigeNumber[i]);

							sleep(50);

						}

						if(Buttons:etectButton(i, Buttons::X) && !MenuOpen[i] && Prestige[i])

						{

							StopPrestige(i);

					         }

guess i now need to learn c++ and how to make sprx plug ins :p

07-27-2014, 06:04 PM #4

OLDSCHOOLMODZHD

Uber Haxor

556

Posts

18,603

Reputation

20

Credits

NextGenUpdate Elite

Apr 2013

NextGenUpdate

Originally posted by Smooth

guess i now need to learn c++ and how to make sprx plug ins :p

sprx is the future Happy

07-27-2014, 06:28 PM #5

Geo

Don't Believe The Title

5,648

Posts

83,380

Reputation

7,386

Credits

NextGenUpdate Elite

Dec 2013

NextGenUpdate

Thanks will ad dis to menu Enzo

07-27-2014, 10:38 PM #6

Swaqq

Professional Thanker

800

Posts

17,079

Reputation

269

Credits

Former Staff

Nov 2013

NextGenUpdate

Release the HUDS? I really wanna make a BO2 Menu SPRX or Ghosts :p

07-27-2014, 10:42 PM #7

OLDSCHOOLMODZHD

Uber Haxor

556

Posts

18,603

Reputation

20

Credits

NextGenUpdate Elite

Apr 2013

NextGenUpdate

Originally posted by NGU

Release the HUDS? I really wanna make a BO2 Menu SPRX or Ghosts :p

I will ask shark but I'm making huds for mw3 Winky Winky

07-27-2014, 10:57 PM #8

Swaqq

Professional Thanker

800

Posts

17,079

Reputation

269

Credits

Former Staff

Nov 2013

NextGenUpdate

EDIT: Nevermind, ur adding them now stare

Last edited by Swaqq ; 07-27-2014 at 10:59 PM. Reason: g g

07-27-2014, 10:58 PM #9

Geo

Don't Believe The Title

5,648

Posts

83,380

Reputation

7,386

Credits

NextGenUpdate Elite

Dec 2013

NextGenUpdate

Originally posted by OLDSCHOOLMODZHD

I will ask shark but I'm making huds for mw3 Winky Winky

Not at home so haven't played with it but just saw video... Really sexy Mr sprx man :p

07-27-2014, 10:59 PM #10

OLDSCHOOLMODZHD

Uber Haxor

556

Posts

18,603

Reputation

20

Credits

NextGenUpdate Elite

Apr 2013

NextGenUpdate

Originally posted by GeoSe7enModding

Not at home so haven't played with it but just saw video... Really sexy Mr sprx man :p

thanks :p