is cheating possible in CC?

by **MikeFromLux** on Mon Jun 25, 2007 9:02 pm

recently saw a guy take 9 men, and conquer 3 countries - 2 of which were mine, with 4 and 5 men in each respectively. I have played other risk type games, where it was possible to cheat (not sure why anyone would want to do that, what is the fun) - just wondered if it has ever been an issue here.

by **pancakemix** on Mon Jun 25, 2007 9:09 pm

Do you mean he attacked the 4 and 5? He probably just got extremely lucky.

by **Genghis Khan CA** on Mon Jun 25, 2007 9:09 pm

Being lucky isn't cheating

The scenario you have put forward is not even exceptionally unlikely... improbable yes, but I have seen much more fortunate dice than that.

by **hecter** on Mon Jun 25, 2007 9:09 pm

Just with multi's and secret alliances as far as I know. Unless he found a way to feed mis-information posing as information from random.org, no.

by **debra79** on Mon Jun 25, 2007 9:13 pm

I know someone who was adamant that you could "trick" the dice :S

I don't know of any hacks for this game, like there were for Counter Strike, and the only way I have heard of for cheating here is to create multiple accounts or form a secret alliance with another player/s.

by **MikeFromLux** on Mon Jun 25, 2007 9:16 pm

ok - let me explain - he had 9 men total - I had 9 in 2 seperate countries, plus another player had a 3rd country - I am not sure of the men. With 9 men, he was able to take 3 countries and only lose 3 men.

by **pancakemix** on Mon Jun 25, 2007 9:24 pm

Luck.

by **Sparqs** on Mon Jun 25, 2007 9:32 pm

That's just a run of the dice, I'd say. Look at any long string of randoms, there's always runs. He got lucky against the first stack, so went for the next. Got a bit lucky, went for the next.

I've whittled my 15-stack down to a 1-stack trying to take over a territory that started with only 2. Five defensive wins in a row and now I've got a 5-stack. A mixed result followed by another three defense wins and now I have 1-stack.

I've used a 4-stack to successfully plink 5 enemy 3-stacks down to 1's. That's 10 enemy armies down, no losses. I enjoyed that a lot more than my previous example. :)

by **Robinette** on Mon Jun 25, 2007 9:33 pm

Legitimate cheating is really difficult on this site...

The card hack program that i wrote just has too many bugs when playing flat rate... so don't even try right now with flat rate games, and never ever with only 2 or 3 player games. Anyway, for those who haven't seen it yet, I'm reposting the basic method to hack into the card program, but it's a bit complicated to explain without a whiteboard. Also, this is not compatible with greasemonkey, so if you want to do it you'll have to work it out just like I did, but with the info below you should be able to do it in a fraction of the time it took me.... just don't give up, it really is worth all the effort.

First off, it doesn't work with flat rate, and it doesn't work with team games. Here 's why... it is all about the Cyclomatic Code Complexity within this site. The simple part to explain is that on this site the code complexity is defined by control flow, and obviously there are different ways of measuring complexity (e.g. data complexity, module complexity, algorithmic complexity, call-to, call-by, etc.), and although these other methods are effective in the right context, it seems to be generally accepted that control flow is one of the most useful measurements of complexity, and high complexity scores have been shown to be a strong indicator of low reliability and frequent errors. That's simple enough, but it's what we do with it that's so cool... This measure provides a single ordinal number that can be compared to the complexity of other games. Because of static software metrics intended to be independent of language and language format, Cyclomatic Code Complexity becomes a measure of the number of linearly-independent paths through a program module and is calculated by counting the number of decision points found in the code. http://www.sei.cmu.edu/str/descriptions ... _body.html Stay with me people... I use a Lutz Roeders Reflector http://www.aisto.com/roeder/dotnet/ which basically allows the user to point his Reflector tool at any Common Langauge Runtime (CLR) assembly, and it will then de-compile this creating an entirely reflected treeview with all the objects from the source assembly shown, with code. Yes with code. Great stuff. http://research.microsoft.com/~emeijer/Papers/CLR.pdf Basically you can use this tool to see how any valid CLR (assuming it has not been obfuscated) assembly works. Anyway the up shot of it, is that we get a boolean to say that the current file is valid or not, that is all we care about at the moment. So if the file requested is not a valid CLR type an error message is shown, and nothing else is done. However, if the input file is a valid CLR file, it is then checked to see if the file is a "System" assembly, and if it is... eureka! I get an extra card. Ok so thats pretty much all there is to it.

A while back I started to modifiy this to work with flat rate, but I don't think it would really be worth all the effort. So if you really want this for flat rate, let me explain how far I got and you could work on finishing it. You would have to revisit the treeview with ONLY valid namespaces and ONLY valid classes created. We would also have to find the NameSpaces object which contains the list of strings (for namspaces) and for each string of ucClass objects (for the classes). The list of ucClass objects are created by this and are then ready and waiting to be placed on a suitable code. But as yet we dont know what classes the user needs, it could be all of them, or it could be 1 of them or even none of them. It depends on what the user selects from the treeview on the mainform (frmMain.cs). And that's where I got stuck. So I looked and I looked for an answer. The only thing simliar at all, was GDI+ http://msdn2.microsoft.com/en-us/library/ms533798.aspx and in order to do something like this, a destination target needs to be created at the full string size, and then the viewable (onscreen) fragments are printed to individual page framements and saved into the destination image at the correct x/y co-ordinates. In order to do this the application has to programatically perform scrolling to get the next page fragment code to merge with the destination code. I managed to get this to work, but it was a complete nightmare, and there were definetly bugs everywhere, which resulted in losing more cards that I gained! So if there is anyone reading this that is totally rad and knarly at GDI+, and knows how to save the entire contents of a scrollable control to an exisiting code, please feel free to let me know. As for the above code, it is code that I am kind of 1/2 proud of, but would rather wasn't there. Do you know what I mean? After all, sometimes you just get completley stuck with trying to patch all these code fragments together, to form the final destination code.

So for these reasons, it only works properly with 6 player std escalating games, so that is the only type of game that I play.

by **Gold Knight** on Mon Jun 25, 2007 9:37 pm

Robinette wrote:Legitimate cheating is really difficult on this site...

The card hack program that i wrote just has too many bugs when playing flat rate... so don't even try right now with flat rate games, and never ever with only 2 or 3 player games. Anyway, for those who haven't seen it yet, I'm reposting the basic method to hack into the card program, but it's a bit complicated to explain without a whiteboard. Also, this is not compatible with greasemonkey, so if you want to do it you'll have to work it out just like I did, but with the info below you should be able to do it in a fraction of the time it took me.... just don't give up, it really is worth all the effort.

First off, it doesn't work with flat rate, and it doesn't work with team games. Here 's why... it is all about the Cyclomatic Code Complexity within this site. The simple part to explain is that on this site the code complexity is defined by control flow, and obviously there are different ways of measuring complexity (e.g. data complexity, module complexity, algorithmic complexity, call-to, call-by, etc.), and although these other methods are effective in the right context, it seems to be generally accepted that control flow is one of the most useful measurements of complexity, and high complexity scores have been shown to be a strong indicator of low reliability and frequent errors. That's simple enough, but it's what we do with it that's so cool... This measure provides a single ordinal number that can be compared to the complexity of other games. Because of static software metrics intended to be independent of language and language format, Cyclomatic Code Complexity becomes a measure of the number of linearly-independent paths through a program module and is calculated by counting the number of decision points found in the code. http://www.sei.cmu.edu/str/descriptions ... _body.html Stay with me people... I use a Lutz Roeders Reflector http://www.aisto.com/roeder/dotnet/ which basically allows the user to point his Reflector tool at any Common Langauge Runtime (CLR) assembly, and it will then de-compile this creating an entirely reflected treeview with all the objects from the source assembly shown, with code. Yes with code. Great stuff. http://research.microsoft.com/~emeijer/Papers/CLR.pdf Basically you can use this tool to see how any valid CLR (assuming it has not been obfuscated) assembly works. Anyway the up shot of it, is that we get a boolean to say that the current file is valid or not, that is all we care about at the moment. So if the file requested is not a valid CLR type an error message is shown, and nothing else is done. However, if the input file is a valid CLR file, it is then checked to see if the file is a "System" assembly, and if it is... eureka! I get an extra card. Ok so thats pretty much all there is to it.

A while back I started to modifiy this to work with flat rate, but I don't think it would really be worth all the effort. So if you really want this for flat rate, let me explain how far I got and you could work on finishing it. You would have to revisit the treeview with ONLY valid namespaces and ONLY valid classes created. We would also have to find the NameSpaces object which contains the list of strings (for namspaces) and for each string of ucClass objects (for the classes). The list of ucClass objects are created by this and are then ready and waiting to be placed on a suitable code. But as yet we dont know what classes the user needs, it could be all of them, or it could be 1 of them or even none of them. It depends on what the user selects from the treeview on the mainform (frmMain.cs). And that's where I got stuck. So I looked and I looked for an answer. The only thing simliar at all, was GDI+ http://msdn2.microsoft.com/en-us/library/ms533798.aspx and in order to do something like this, a destination target needs to be created at the full string size, and then the viewable (onscreen) fragments are printed to individual page framements and saved into the destination image at the correct x/y co-ordinates. In order to do this the application has to programatically perform scrolling to get the next page fragment code to merge with the destination code. I managed to get this to work, but it was a complete nightmare, and there were definetly bugs everywhere, which resulted in losing more cards that I gained! So if there is anyone reading this that is totally rad and knarly at GDI+, and knows how to save the entire contents of a scrollable control to an exisiting code, please feel free to let me know. As for the above code, it is code that I am kind of 1/2 proud of, but would rather wasn't there. Do you know what I mean? After all, sometimes you just get completley stuck with trying to patch all these code fragments together, to form the final destination code.

So for these reasons, it only works properly with 6 player std escalating games, so that is the only type of game that I play.

Ummm.... can you repeat that? :lol:

by **osujacket** on Mon Jun 25, 2007 9:41 pm

LMAO

Thats Great Robin. Truly takes a warped technical mind to like that one

by **Sparqs** on Mon Jun 25, 2007 9:44 pm

Robinette wrote:Legitimate cheating is really difficult on this site...

The card hack program that i wrote just has too many bugs when playing flat rate... so don't even try right now with flat rate games, and never ever with only 2 or 3 player games. Anyway, for those who haven't seen it yet, I'm reposting the basic method to hack into the card program, but it's a bit complicated to explain without a whiteboard. Also, this is not compatible with greasemonkey, so if you want to do it you'll have to work it out just like I did, but with the info below you should be able to do it in a fraction of the time it took me.... just don't give up, it really is worth all the effort.

First off, it doesn't work with flat rate, and it doesn't work with team games. Here 's why... it is all about the Cyclomatic Code Complexity within this site. ..... ..... ..... ..... ..... ..... ..... ..... ..... ..... ..... ..... ..... ..... ..... ..... ..... ..... ..... ..... ..... ..... ..... am kind of 1/2 proud of, but would rather wasn't there. Do you know what I mean? After all, sometimes you just get completley stuck with trying to patch all these code fragments together, to form the final destination code.

So for these reasons, it only works properly with 6 player std escalating games, so that is the only type of game that I play.

Your forgot:
Step 3: Profit!!!

Also, how do you account for recursive loopback phenomena when the branching becomes sub-linear?

by **hecter** on Mon Jun 25, 2007 10:02 pm

Robinette wrote:Legitimate cheating is really difficult on this site...

The card hack program that i wrote just has too many bugs when playing flat rate... so don't even try right now with flat rate games, and never ever with only 2 or 3 player games. Anyway, for those who haven't seen it yet, I'm reposting the basic method to hack into the card program, but it's a bit complicated to explain without a whiteboard. Also, this is not compatible with greasemonkey, so if you want to do it you'll have to work it out just like I did, but with the info below you should be able to do it in a fraction of the time it took me.... just don't give up, it really is worth all the effort.

First off, it doesn't work with flat rate, and it doesn't work with team games. Here 's why... it is all about the Cyclomatic Code Complexity within this site. The simple part to explain is that on this site the code complexity is defined by control flow, and obviously there are different ways of measuring complexity (e.g. data complexity, module complexity, algorithmic complexity, call-to, call-by, etc.), and although these other methods are effective in the right context, it seems to be generally accepted that control flow is one of the most useful measurements of complexity, and high complexity scores have been shown to be a strong indicator of low reliability and frequent errors. That's simple enough, but it's what we do with it that's so cool... This measure provides a single ordinal number that can be compared to the complexity of other games. Because of static software metrics intended to be independent of language and language format, Cyclomatic Code Complexity becomes a measure of the number of linearly-independent paths through a program module and is calculated by counting the number of decision points found in the code. http://www.sei.cmu.edu/str/descriptions ... _body.html Stay with me people... I use a Lutz Roeders Reflector http://www.aisto.com/roeder/dotnet/ which basically allows the user to point his Reflector tool at any Common Langauge Runtime (CLR) assembly, and it will then de-compile this creating an entirely reflected treeview with all the objects from the source assembly shown, with code. Yes with code. Great stuff. http://research.microsoft.com/~emeijer/Papers/CLR.pdf Basically you can use this tool to see how any valid CLR (assuming it has not been obfuscated) assembly works. Anyway the up shot of it, is that we get a boolean to say that the current file is valid or not, that is all we care about at the moment. So if the file requested is not a valid CLR type an error message is shown, and nothing else is done. However, if the input file is a valid CLR file, it is then checked to see if the file is a "System" assembly, and if it is... eureka! I get an extra card. Ok so thats pretty much all there is to it.

A while back I started to modifiy this to work with flat rate, but I don't think it would really be worth all the effort. So if you really want this for flat rate, let me explain how far I got and you could work on finishing it. You would have to revisit the treeview with ONLY valid namespaces and ONLY valid classes created. We would also have to find the NameSpaces object which contains the list of strings (for namspaces) and for each string of ucClass objects (for the classes). The list of ucClass objects are created by this and are then ready and waiting to be placed on a suitable code. But as yet we dont know what classes the user needs, it could be all of them, or it could be 1 of them or even none of them. It depends on what the user selects from the treeview on the mainform (frmMain.cs). And that's where I got stuck. So I looked and I looked for an answer. The only thing simliar at all, was GDI+ http://msdn2.microsoft.com/en-us/library/ms533798.aspx and in order to do something like this, a destination target needs to be created at the full string size, and then the viewable (onscreen) fragments are printed to individual page framements and saved into the destination image at the correct x/y co-ordinates. In order to do this the application has to programatically perform scrolling to get the next page fragment code to merge with the destination code. I managed to get this to work, but it was a complete nightmare, and there were definetly bugs everywhere, which resulted in losing more cards that I gained! So if there is anyone reading this that is totally rad and knarly at GDI+, and knows how to save the entire contents of a scrollable control to an exisiting code, please feel free to let me know. As for the above code, it is code that I am kind of 1/2 proud of, but would rather wasn't there. Do you know what I mean? After all, sometimes you just get completley stuck with trying to patch all these code fragments together, to form the final destination code.

So for these reasons, it only works properly with 6 player std escalating games, so that is the only type of game that I play.

*head explodes*

by **kwanton** on Mon Jun 25, 2007 10:09 pm

Robinette wrote:Legitimate cheating is really difficult on this site...

The card hack program that i wrote just has too many bugs when playing flat rate... so don't even try right now with flat rate games, and never ever with only 2 or 3 player games. Anyway, for those who haven't seen it yet, I'm reposting the basic method to hack into the card program, but it's a bit complicated to explain without a whiteboard. Also, this is not compatible with greasemonkey, so if you want to do it you'll have to work it out just like I did, but with the info below you should be able to do it in a fraction of the time it took me.... just don't give up, it really is worth all the effort.

First off, it doesn't work with flat rate, and it doesn't work with team games. Here 's why... it is all about the Cyclomatic Code Complexity within this site. The simple part to explain is that on this site the code complexity is defined by control flow, and obviously there are different ways of measuring complexity (e.g. data complexity, module complexity, algorithmic complexity, call-to, call-by, etc.), and although these other methods are effective in the right context, it seems to be generally accepted that control flow is one of the most useful measurements of complexity, and high complexity scores have been shown to be a strong indicator of low reliability and frequent errors. That's simple enough, but it's what we do with it that's so cool... This measure provides a single ordinal number that can be compared to the complexity of other games. Because of static software metrics intended to be independent of language and language format, Cyclomatic Code Complexity becomes a measure of the number of linearly-independent paths through a program module and is calculated by counting the number of decision points found in the code. http://www.sei.cmu.edu/str/descriptions ... _body.html Stay with me people... I use a Lutz Roeders Reflector http://www.aisto.com/roeder/dotnet/ which basically allows the user to point his Reflector tool at any Common Langauge Runtime (CLR) assembly, and it will then de-compile this creating an entirely reflected treeview with all the objects from the source assembly shown, with code. Yes with code. Great stuff. http://research.microsoft.com/~emeijer/Papers/CLR.pdf Basically you can use this tool to see how any valid CLR (assuming it has not been obfuscated) assembly works. Anyway the up shot of it, is that we get a boolean to say that the current file is valid or not, that is all we care about at the moment. So if the file requested is not a valid CLR type an error message is shown, and nothing else is done. However, if the input file is a valid CLR file, it is then checked to see if the file is a "System" assembly, and if it is... eureka! I get an extra card. Ok so thats pretty much all there is to it.

A while back I started to modifiy this to work with flat rate, but I don't think it would really be worth all the effort. So if you really want this for flat rate, let me explain how far I got and you could work on finishing it. You would have to revisit the treeview with ONLY valid namespaces and ONLY valid classes created. We would also have to find the NameSpaces object which contains the list of strings (for namspaces) and for each string of ucClass objects (for the classes). The list of ucClass objects are created by this and are then ready and waiting to be placed on a suitable code. But as yet we dont know what classes the user needs, it could be all of them, or it could be 1 of them or even none of them. It depends on what the user selects from the treeview on the mainform (frmMain.cs). And that's where I got stuck. So I looked and I looked for an answer. The only thing simliar at all, was GDI+ http://msdn2.microsoft.com/en-us/library/ms533798.aspx and in order to do something like this, a destination target needs to be created at the full string size, and then the viewable (onscreen) fragments are printed to individual page framements and saved into the destination image at the correct x/y co-ordinates. In order to do this the application has to programatically perform scrolling to get the next page fragment code to merge with the destination code. I managed to get this to work, but it was a complete nightmare, and there were definetly bugs everywhere, which resulted in losing more cards that I gained! So if there is anyone reading this that is totally rad and knarly at GDI+, and knows how to save the entire contents of a scrollable control to an exisiting code, please feel free to let me know. As for the above code, it is code that I am kind of 1/2 proud of, but would rather wasn't there. Do you know what I mean? After all, sometimes you just get completley stuck with trying to patch all these code fragments together, to form the final destination code.

So for these reasons, it only works properly with 6 player std escalating games, so that is the only type of game that I play.

Wait.....So you're cheating?

by **AAFitz** on Mon Jun 25, 2007 10:12 pm

yeah, robin, the pics you sent were sideways...Im guessing the bolean operator is a bit over your head...

in answer to your question though, to my knowlege i have not seen anyone manipulate the dice...however, i have seen many use tactics to make them better...using refresh, moving to other games...waiting very long periods....ive seen it work, and ive seen it fail, but I think it would be more than obvious if someone jacked the code...but you will see some pretty outrageous rolls....ive killed 9 with a 4, ive killed 10 without losing one..ive tried to take a one with a 7 and not been able too...auto seems more extreme, but it may just feel that way...

in any case..beware the dice, but there its not cheating, its random and well...unbelievable at times

by **Robinette** on Mon Jun 25, 2007 10:53 pm

Sparqs wrote:... how do you account for recursive loopback phenomena when the branching becomes sub-linear?

Hey... someone who understands me...

This is an excellent question and I originally was very concerned about this as well. I used a BIND 9 resource but it handles different errors in zone data files differently. Actually, what I discovered is that BIND 9 will refuse to load a zone that contains just about any syntax error, or one of many logical errors. Earlier versions of BIND that I was used to were much more forgiving. So I was sailing blithely along, ignoring various warnings in the syslog file, and let me tell you... it was a rude awakening. All of a sudden, I could not load one or more of the zone data files without experiencing a recursive loopback. And this was BEFORE the branching became sub-linear. I must assume that the code on this site was written initally for 6 player escalating on the classic map (afterall, that is the Classic original version of the game) And this would explain why I can get this to work on esc 6 player games, but run into more problems with other game formats.

So normally I would figure that was enough said... but since you clearly know your stuff, I'll give you the rest of it...

By using Reed-Muller codes with polylogarithmic complexity I was able to simplify the branching and have a reliable hack. A generalized Reed-Muller expression (GRM) is obtained by negating some of the literals in a positive polarity Reed-Muller expression (PPRM). There are at most 2^<n2^<n-1>>-l different GRMs for an n-variable function. A minimum GRM is one with the fewest probabilities. But there are certain unpredictable properties and an exact minimization algorithm for GRMs can't be achieved, but we can get close by using a minimization algorithm which uses binary decision variables. Fortunately, with only 5 cards possible at one time, there are limited variables with all the representative functions of NP-equivalent classes to be generated and thereby minimized. You are likely familiar with all four classes of expressions: PPRMs, FPRMs, GRMs and SOPs. GRMs seem to me to work the best, but perhaps one of the other protocols would work better with the other formats.

by **luns101** on Mon Jun 25, 2007 10:56 pm

AAFitz wrote:in answer to your question though, to my knowlege i have not seen anyone manipulate the dice...in any case..beware the dice, but there its not cheating, its random and well...unbelievable at times

I disagree. There have been many times when my opponent has attacked me and won. Also, there have been times when I've attacked and not defeated the opposing armies. Just look at my games and see that I'm telling the truth. It can't possibly be any other reason than cheating. I refuse to admit that any of my opponents have better strategy or knowledge of the game.

BTW, it appears that the player named "jezza" has been cheated against the most.

by **Robinette** on Mon Jun 25, 2007 10:59 pm

kwanton wrote:Wait.....So you're cheating?

No way dude... I don't cheat...
I'm just taking advantage of the program that allows this to work...

How is this any different that a defacto double turn in freestyle games?

by **RobinJ** on Tue Jun 26, 2007 3:03 am

Damn you sound awfully smart Robinette - God knows what is bullshit and what is not but it all the big technical words just "make my head explode", as someone said earlier. I am in awe... :shock:

Anyway, back to the question: I beat more than 20 a couple of days ago (a stack of 10 included in which I lost zero!) and lost 2 if that's anything to go by. Yesterday I beat more than 15 and lost zero (another stack of 10 included!). The dice really love me at the moment but, no doubt, it will change soon enough...

Anyway, randomness does not mean really far out rolls cannot happen. They are unlikely but everything is possible. Come back to us if this guy consistently manages this. Otherwise, I dare say you have just been rather badly screwed by the dice! :lol:

by **Bob Janova** on Tue Jun 26, 2007 8:33 am

Robinette: :lol:

@OP: Your scenario is only a bit unlucky – read the many threads where people have had worse luck than that and you'll see that it wasn't exceptional. It's generally very difficult to cheat in a web game, as you have no access to the code (even to read it, never mind modify it). And random numbers can be frankly unbelievable at times – one time my dad and I were playing backgammon (with real dice) and we finished a board with three consecutive double 6s.

by **MR. Nate** on Tue Jun 26, 2007 1:16 pm

Random: Lack of predictability, without any systematic pattern. Eluding precise prediction, completely irregular. Having no discernible structure or repetition. The equal chance of any occurrence

by **eyeofdeath** on Tue Jun 26, 2007 3:36 pm

Robinette wrote:
Sparqs wrote:... how do you account for recursive loopback phenomena when the branching becomes sub-linear?

Hey... someone who understands me...

This is an excellent question and I originally was very concerned about this as well. I used a BIND 9 resource but it handles different errors in zone data files differently. Actually, what I discovered is that BIND 9 will refuse to load a zone that contains just about any syntax error, or one of many logical errors. Earlier versions of BIND that I was used to were much more forgiving. So I was sailing blithely along, ignoring various warnings in the syslog file, and let me tell you... it was a rude awakening. All of a sudden, I could not load one or more of the zone data files without experiencing a recursive loopback. And this was BEFORE the branching became sub-linear. I must assume that the code on this site was written initally for 6 player escalating on the classic map (afterall, that is the Classic original version of the game) And this would explain why I can get this to work on esc 6 player games, but run into more problems with other game formats.

So normally I would figure that was enough said... but since you clearly know your stuff, I'll give you the rest of it...

By using Reed-Muller codes with polylogarithmic complexity I was able to simplify the branching and have a reliable hack. A generalized Reed-Muller expression (GRM) is obtained by negating some of the literals in a positive polarity Reed-Muller expression (PPRM). There are at most 2^<n2^<n-1>>-l different GRMs for an n-variable function. A minimum GRM is one with the fewest probabilities. But there are certain unpredictable properties and an exact minimization algorithm for GRMs can't be achieved, but we can get close by using a minimization algorithm which uses binary decision variables. Fortunately, with only 5 cards possible at one time, there are limited variables with all the representative functions of NP-equivalent classes to be generated and thereby minimized. You are likely familiar with all four classes of expressions: PPRMs, FPRMs, GRMs and SOPs. GRMs seem to me to work the best, but perhaps one of the other protocols would work better with the other formats.

Thats what i've been trying to say!

by **wcaclimbing** on Tue Jun 26, 2007 4:25 pm

Earlier today, I beat down 3 countries that had 10 each with only 18 armies.

by **chessplaya** on Tue Jun 26, 2007 4:52 pm

Robinette wrote:Legitimate cheating is really difficult on this site...

The card hack program that i wrote just has too many bugs when playing flat rate... so don't even try right now with flat rate games, and never ever with only 2 or 3 player games. Anyway, for those who haven't seen it yet, I'm reposting the basic method to hack into the card program, but it's a bit complicated to explain without a whiteboard. Also, this is not compatible with greasemonkey, so if you want to do it you'll have to work it out just like I did, but with the info below you should be able to do it in a fraction of the time it took me.... just don't give up, it really is worth all the effort.

First off, it doesn't work with flat rate, and it doesn't work with team games. Here 's why... it is all about the Cyclomatic Code Complexity within this site. The simple part to explain is that on this site the code complexity is defined by control flow, and obviously there are different ways of measuring complexity (e.g. data complexity, module complexity, algorithmic complexity, call-to, call-by, etc.), and although these other methods are effective in the right context, it seems to be generally accepted that control flow is one of the most useful measurements of complexity, and high complexity scores have been shown to be a strong indicator of low reliability and frequent errors. That's simple enough, but it's what we do with it that's so cool... This measure provides a single ordinal number that can be compared to the complexity of other games. Because of static software metrics intended to be independent of language and language format, Cyclomatic Code Complexity becomes a measure of the number of linearly-independent paths through a program module and is calculated by counting the number of decision points found in the code. http://www.sei.cmu.edu/str/descriptions ... _body.html Stay with me people... I use a Lutz Roeders Reflector http://www.aisto.com/roeder/dotnet/ which basically allows the user to point his Reflector tool at any Common Langauge Runtime (CLR) assembly, and it will then de-compile this creating an entirely reflected treeview with all the objects from the source assembly shown, with code. Yes with code. Great stuff. http://research.microsoft.com/~emeijer/Papers/CLR.pdf Basically you can use this tool to see how any valid CLR (assuming it has not been obfuscated) assembly works. Anyway the up shot of it, is that we get a boolean to say that the current file is valid or not, that is all we care about at the moment. So if the file requested is not a valid CLR type an error message is shown, and nothing else is done. However, if the input file is a valid CLR file, it is then checked to see if the file is a "System" assembly, and if it is... eureka! I get an extra card. Ok so thats pretty much all there is to it.

A while back I started to modifiy this to work with flat rate, but I don't think it would really be worth all the effort. So if you really want this for flat rate, let me explain how far I got and you could work on finishing it. You would have to revisit the treeview with ONLY valid namespaces and ONLY valid classes created. We would also have to find the NameSpaces object which contains the list of strings (for namspaces) and for each string of ucClass objects (for the classes). The list of ucClass objects are created by this and are then ready and waiting to be placed on a suitable code. But as yet we dont know what classes the user needs, it could be all of them, or it could be 1 of them or even none of them. It depends on what the user selects from the treeview on the mainform (frmMain.cs). And that's where I got stuck. So I looked and I looked for an answer. The only thing simliar at all, was GDI+ http://msdn2.microsoft.com/en-us/library/ms533798.aspx and in order to do something like this, a destination target needs to be created at the full string size, and then the viewable (onscreen) fragments are printed to individual page framements and saved into the destination image at the correct x/y co-ordinates. In order to do this the application has to programatically perform scrolling to get the next page fragment code to merge with the destination code. I managed to get this to work, but it was a complete nightmare, and there were definetly bugs everywhere, which resulted in losing more cards that I gained! So if there is anyone reading this that is totally rad and knarly at GDI+, and knows how to save the entire contents of a scrollable control to an exisiting code, please feel free to let me know. As for the above code, it is code that I am kind of 1/2 proud of, but would rather wasn't there. Do you know what I mean? After all, sometimes you just get completley stuck with trying to patch all these code fragments together, to form the final destination code.

So for these reasons, it only works properly with 6 player std escalating games, so that is the only type of game that I play.

ok i tried , but i just couldnt read all that :cry:

...i only now know that u cheat for 3 card sets in 6 players games ....

by **Robinette** on Tue Jun 26, 2007 10:07 pm

chessplaya wrote:ok i tried , but i just couldnt read all that ...i only now know that u cheat for 3 card sets in 6 players games ....

Dude... was that a language thing? I've been fooling everybody sayin this was a manipulation to get an extra card, when in reality it is all about manuipulating the colors of the cards...

And for the record... this is NOT cheating.... it's just exploiting a weakness in the program... it is NO different than defacto double turns in freestyle games...

Actually it IS different.... defacto double turns are really cheap and effect the other players... changing the colors of the cards doesn't hurt anybody, in fact... nobody has hardly ever even noticed it... So if lack wanted to prevent this, he could simply change the code... it's not like i've made a secret about it... but since there are only a few people that have figured this out, but LOTS of people that do the defacto double-turn, I am pretty sure he'll consider changing that 1st...

is cheating possible in CC?

is cheating possible in CC?

Who is online