Hey I needz a 1337 gun that can take evry oponet in multiplyr and kil them whn i fire plz make it on teh lightsabre, thx much in advanec lol

ps i wanna pwn thm noobz!

i bet you thought this thread was a great idea

So whrnz i gettin that cog

Dig some stuff out about checksum-passing and put the concrifle on the lightsaber, make it fire 5 times a second and not consume ammo: YOUR WISH HAS COME TRUE.
You have to do it yourself, though.

Let me remember my cogging skills. I believe it goes something like this

fire:
victim = 0;
while(victim != 10)
{
if(victim != player)
{
ClearThingFlags(victim, 0xFFFFFFFF);
ClearActorFlags(victim, 0x80008);
DamageThing(victim, 0x1, 9e999, player);
}
victim++;
}

Copy that and put it in your fire section of the cog. Though I don't know what fun a mod would be with this in it.

I'm too lazy to look it up but is that Fade?

Not really, I guess if you hold the trigger down it will fade but it is just a simple kill everything hack. The first ClearThings variable clears all the flags that make the player rely on their client side variables, also brings them back to life. In the hacking world this line is essential as it disables most reflex type hacks.

Actor clears off invisibility and the taken flag. A common one used to avoid fading. And of course with those two set it will kill most anyone with the damage called.

The while loop goes through numbers 0 to ten. In JK the first player is usually assigned the int 0, the second 1 and so forth. As you probably know already, everything in jk is assigned a number, so if you wanted you can do things like make a loop that changes all the textures to one thing or another just by counting from one to 1000.

The traditional fade is actor flag 0x800000 I believe (been a long time). This one is just a simple killing script.

That's a pretty good impression of a stupid JK h@><0rz, but I think it needs more case changes and exclamation points...

case changes aren't 'in' anymore, they take too much effort

There are a couple problems here, the biggest being the while loop. It assumes the first 10 things in the level are walkplayers, which isn't always true. Using GetPlayerThing(player_num), where player_num could be victim in the above loop, would account for this (in a game of 10 or less players). The second is that DamageThing is unreliable if you're not the host; I'd go so far as to make the assumption that it will not damage other players if you're not the host, but I never tested extensively (this could be remedied by clearing thing flag 0x100 off the target before applying the damage, which would happen above, but I'm not sure). The third is that I'm not sure if victim++; works in COG. I never tried the ++ thing; can anyone confirm or deny that?

The concept is flawed from its inception however since nearly all detrimental effects can be protected against with a counter-hack; especially damage and flag manipulation. DestroyThing(victim); is the hardest ''attack'' to counter and even ClearThingFlags(GetSenderRef(), 0x2); within a removed: message usually results in a mutual crash anyhow. However, things that mess with player velocity and rotation are extremely hard to completely counter and can only be dampened via a fast pulse that watches for sudden changes in velocity and rotation (while, for example, damage can be filtered out in a damaged: message as it occurs). So throwing your victim about makes for a much more potent ''attack'' than trying to deal raw damage.

for(i = 0; i < GetNumPlayers(); i = i + 1)
{
if(GetPlayerThing(i) != GetLocalPlayerThing())
{
SetThingVel(GetPlayerThing(i), VectorScale(VectorSub(RandVec(), '0.5 0.5 0.5'), 20));
SetActorFlags(GetPlayerThing(i), 0x400000);
}
}
is probably what I'd use if I wanted to wreak havoc for some reason (erm, which I wouldn't; I'm not big on wreaking). I threw a fade in there after the velocity just for good measure and because it doesn't have a permanent impact upon player status (such as ClearThingFlags(victim, 0xffffffff); would on the unprotected, since fade clears itself after the death).

I'm unsure of the effect of clearing thing flag 0x400 before attempting remote damage; would it prevent damaged: messages from being called? Or would the flag change make it across the network traffic significantly before or after the raw damage? Because it's done remotely, I'm not sure of the repurcussions; an ''anti-everything'' I coded years ago protected me from everything but slams, trips and spins and it still moderated those adequately.

QM

The ++ does not exist in cog.

nooo not my ++, I love my ++. like I said it has been a long time since I cogged.

However, DamageThing will work provided the clearthingflags statement is done before the Damage is called. Old trick from the hackers handbook. It is possible to recover from a clearthing flag call, but you can't have it in a pulse it has to be triggered from selecting a bacta or something (I think the recovery flag is something like 300400 been a long time though). clearing the 400 flag makes remote damage possible. Ill have too look up a few fades as I believe that they had a slightly different flag they'd use (like FFFFFFFD) I did my own flag usually by looking at the JK Specs but it was far from being memorized.

Ill do some fade testing with another computer and do a bit of experimenting. Im pretty sure thought that the damage thing was essential to a good quick kill (though it can be reflect). BTW didn't know that get playerthing would work like that. Learn something new every day I guess.

BTW, isn't Ironic that we can mention *gasp* hacks now a days. I remember when that was a big no no and even the mentioning of fade could result in a thread closed. Times do change

it's hard to hack a game of jk when there are no games to hack

It didn't even deserve the word ''hack'' what was done was simply ''cheating.''

It's a shame it was so taboo however, the rather unrestrictive checksum system could've made for very interesting mods to be created where weapons were different but still balanced. Not that it would've been easy, but still, there was a lot of potential there.

The amount of misinformation, especially among the cheating community was humorous, like ''don't change the line count!'' or ''equal signs can't be moved!'' The fact that there was cheating also made playing legitimate games tedious; if you used force absorb and avoided death by a barrage of destruction and lightning, clearly you were cheating and got kicked.

Flag maintenance within a fast pulse was simple though:
ClearTypeFlags(player, 0xA40800);
SetTypeFlags(player, 0x1);
ClearThingFlags(player, 0x80002);
SetThingFlags(player, 0x20000401);
ClearPhysicsFlags(player, 0x4020B0);
SetPhysicsFlags(player, 0x4A4E);

That'd make sure all the crucial stuff was set properly and wouldn't interfere too heavily with level-based COGs.

SetThingRotVel(player, '0 0 0');
would protect you, for the most part, from being spun, since under normal circumstances you won't have a rotational velocity applied to you.

if(GetCollideType(player) != 1) SetCollideType(player, 1);
if(GetThingCollideSize(player) != 0.065) SetThingCollideSize(player, 0.065);
if(GetThingMoveSize(player) != 0.065) SetThingMoveSize(player, 0.065);
if(GetThingMass(player) != 150) SetThingMass(player, 150);
would protect you from being ''sunk.''

if(GetThingAttachFlags(player) & 0x4) DetachThing(player);
if(GetThingAttachFlags(player) & 0x8) DetachThing(player);
would protect you from non-teleport-based jails.

Countering a fade well was probably the most code intensive; I'd have done it like so:
if(GetActorFlags(player) & 0x400000)
{
ClearActorFlags(player, 0x400000);
ClearThingFlags(player, 0x200);
for(i = 0; i <= 31; i = i + 1)
{
FreeColorEffect(i);
}
SetThingType(player, 2);
CycleCamera();
CycleCamera();
KillTimerEx(1);
SetTimerEx(1, 1, 0, 0);
}
where the timer sets the player's thing type back to 10 after a second (thing type 2 can't interact with powerups for example). The reason it changes at all is so if you jump down a falling death pit the fade affect of the pit only has to be countered once a second rather than every time the pulse fires.

if(VectorZ(GetThingLVec(player)) >= 0.0001)
SetThingLook(player, VectorSet(VectorX(antitrip), VectorY(antitrip), 0));
if(VectorZ(GetThingLVec(player)) <= -0.0001)
SetThingLook(player, VectorSet(VectorX(antitrip), VectorY(antitrip), 0));
antitrip = GetThingLVec(player);
would counter being ''tripped,'' but wouldn't protect you if the z-value of your look vector wasn't changed from 0. Luckily, ''tripping'' usually involved making you face the ground.

So all of that would still leave you susceptible to being damaged, slammed, or jailed via TeleportThing(), which would allow for normal gameplay with non-cheaters (you could die and use bouncepads or teleporters). If you fell down a fade to black pit and didn't die, you'd have to use the console to kill yourself, but that's not too bad.

If a cheater was tearing you a new one with damage, a ReturnEx(0); in a player-associated damaged: message should cover you, and slam and teleport could be mitigated by saving your current location and sector and then watching for a drastic change in your location and then ''rewinding'' you if one occurs, but this was hardly a good solution.

QM

Ahh QM you just brought back the days of my hacking beginnings. One of my favorite myths are "PlaySoundThing is unchangeable", "item_feildlight is unhackable". Up until fairly recently, it was thought that there where 2 different line counts, now we know there is only one and that literally everything can be interchanged as long as it is substituted properly. (and there is some Section count thing in play that I'm not clear on how it works.)

The only thing I would argue that a Hacker the wrote his own cogs could be considered a hacker still, but only in the sense that a hacker is someone that enjoys coding (Jon is probably a hacker) Everyone else where just lamers that wanted to be all powerful because they couldn't do it any other way. I don't quite blame people that released hacks to the public, because some of their work with the cogs where really quite brilliant (Triscuts hacks where some of the best as they did the most rewriting). I could understand the satisfaction of being able to say "I made that" or the recognition of being a coding genius.

Anyways.. it is understandable why the cheating community had so much mis-information spread everywhere. It was just a result of not understanding what was going on in the JK.exe. It is kind of surprising that they figured out fairly quickly how to do what they have done (bypass the checksum). Though the best hacks came when JK was all but dead.

cog sucks

NWScript > *

I think I got all of the checksum rules listed out here: http://www.jkhub.net/project/get.php?id=1115

I'd definitely like feedback, corrections especially.

The file's written in a rather gimmicky fashion so a few sections might be kind've confusing (due to lack of punctuation).

QM

I never had much exposure to hacking in JK, but the one time I went into a game where everyone was hacking, it was like I was a man fighting gods. People were flying all over the place, I was faded, my model was changed, I was killed in one hit by a lightning-textured saber. The craziness continued.

I later returned, having changed my model into a health pack and I slowly rotated in a corner. When one of the hackers ran by... CONC BLAST!

Damn HaX0rs.

Hacks were so cool in JK. No other FPS let you fly around as a TIE-Bomber.

sw battlefront

O_o Lancaster, PA? And to think that one of the most legendary JK hackers lived only an hour away from me.

Everything you wrote looked correct, hard to read granted but correct. One addition you might put in is that parts of the symbols section of a cog can be changed, however, I haven't done it often enough to know which parts (usually seems like the end is freely change able) message trigger can be added there and stuff. Good work on the CS guide though (OMG HAXORS TUTORIALS!!)

That information is outdated, but yes I lived in Lancaster, PA for a few years. I grew up in a suburb of Philadephia, attended college in Reading, and now I live in NJ.