How can I prevent players from cheating on their stats that carry between games?

Question

I have created a card game that allows players to advance. The problem is that you can keep your stats until your next game (with anybody else). For the life of me, I can't find out how to be able to "prove" that the stats are valid (other than keeping a booklet or something, which I already am doing, but they could just fake what is in their booklet too)? For example, if I'm playing with someone new, how can I ensure that if they say they are on the top tier, they are telling the truth?

I could put in the rules that anybody caught cheating will automatically be downgraded to the bottom tier, or some other penalty, but how do I PROVE that they are cheating? Maybe a different method of going up tiers? Or keeping track of going up tiers?

Any suggestions would be greatly appreciated! I've been racking my brain about this. The whole game revolves around being able to go up tiers, but I don't want people to cheat.

Answer 1

Make it so that it doesn't matter if players have faked their profile.

Say having a high ranked profile means that you have access to better equipment (and therefore an incentive to produce a fake profile). You could reduce the impact of this by (say) introducing a handicap for high ranked players when playing against lower ranked players.

If there is a handicap system (or some similar mechanic) that balances the game, it doesn't matter for a casual game if one player has a faked profile, since neither player has an unfair advantage.

I'm also assuming casual games with unknown players would be the main problem, because:

• If you repeatedly face the same opponent(s), you'll start to notice them doctoring their profile between games
• If you're having a tournament, it probably makes sense for the tournament body to hold the profiles and check them between games.

As an aside, this also opens up your game to other demographics. For example, on D&D, there are players that would prefer to start at a high level with a bunch of equipment already. Also, if it doesn't matter if the profiles have been built "correctly" or not, then players can fabricate profiles to see how a different set of choices would play out.

Answer 2

This is a very difficult question to answer, and it's probably the reason that persistent, player power modifying changes are not included in most card games.

one possible solution is a central online data store/mobile app

This may be beyond your project, but one solution would be to implement some form of website wherein player profiles can be stored, this website would allow you to keep control of player profiles, and give players confidence that their opponent cannot (at least, legally or easily) compromise the data stored in your database.

Depending on how your system works, registering win/loss may be enough for tracking advancement, in which case players can each register a match and its result (or one player can propose a match/result, which the other must confirm).

If characteristics of the match must be tracked as well (e.g. if casting a certain type of spell increases a certain statistic) this can also be tracked in a similar way, just requiring some more detail on behalf of your players.

All of the above however only solves the problem of individuals trying to cheat. If a pair or group wish to cheat, they could just register alternating wins/losses against each other to advance at a high rate. Diminishing returns could be included to combat this, however it would still not resolve the issue of a larger group gaming their stats in the run up to a large tournament (you can only limit this behaviour so much before you have a negative impact on small play groups who regularly play against each other)

Another option would be to produce something similar to how planeswalker points are handled in Magic: The Gathering, which is that your tournament record is uploaded by the tournament organiser (using software provided by Wizards of the coast, who make MTG, which uploads the list of all players, all matches that took place, and who wins each match). This removes the opportunity for any size group of players to cheat, providing that your tournament organisers can be kept trustworthy (keeping your tournament organisers invested in being trustworthy by giving them a lot of rewards like free promos/product, and then removing all rewards and all ability to organise play where that trust is broken). This would allow you to track player movements in probably the most secure way possible, and does not require the same production of a full featured mobile app that players can (and crucially, enjoy) use to track their play.

I will say one thing however. There is a reason no other card game has an advancement system, and it isn't that no one has thought of it before. It is difficult enough to keep play fair without a system like this which can be potentially gamed for an advantage. Card games (particularly collectible ones) have a big enough barrier to entry already, in that cards can be particularly expensive, having an innate disadvantage from being new BESIDES not owning all the cards is going to have a significant impact on getting new players into your game. Getting new players and keeping them has to be absolutely one of your top priorities, because players leave all the time, and if you don't have a steady stream of new players coming in, you will kill your game stone dead. Nobody plays a game if they cant play it with anyone, and if no one new takes it up, it will fizzle out very quickly.

A better solution is to reward regular players with Aesthetic bonuses, such as Promos, Shiny things, free stuff that no one else gets. This encourages long term play as well (if not better) as tangible game advantage, without discouraging new players (in fact, it encourages them to stick with it)

Answer 3

Checksums, CRCs, Hashes, etc.

Computer science has a possible solution for this. In computer science, sometimes you need to verify that some received data hasn't been altered or corrupted. The simplest way to validate the data is called a checksum. If I have a sequence of data bytes, say [23, 128, 55], the checksum is calculated by summing all the bytes (23+128+55=206) and for reasons I won't get into, is subtracted from 256 (256 - 206 = 50). The last byte is added to the data --> [23, 128, 55, 50]. When I receive the data, I calculate the checksum and compare it to the transmitted checksum included with the data. If they are the same then the data wasn't accidentally altered.

Now this is all heavily math based and obviously wouldn't work with a card game. However, you could adapt the basic idea. For example. you could evenly distribute some a set of abstract symbols across all the cards, e.g. take the shapes: circle (C), triangle (T), square (S), pentagon (P), and randomly assign one to each card. At the end of the game, players count the number of each symbol and tell you (E.g. "My deck has 3 circle cards, 1 triangle card, 5 square cards, 2 pentagon cards, for the value '3C1T5S2P'). You can record the 'checksum' of each deck and verify it if necessary during the next session.

While players could still alter their deck, they can't make any arbitrary change without having to make other changes as well. For example a +1 sword might have a circle symbol, but the +2 sword is a square. If they want to secretly upgrade themselves, they'll have to find some square card in their deck and swap it out for a circle to make the checksums the same. You could greatly increase the difficulty by have several shapes with different colors (for example, circle, triangle, square, pentagon, each which comes in one of three colors: black, green, and purple (these colors chosen to make the game color-blind friendly)). Now they need to make sure that the color and shapes all match up, but at the expense of having a more difficult checksum sequence to record and calculate.

Since I don't know any specifics about your game, this example probably won't apply very well, but you should be able to adapt it to your needs. You can read up on the concepts (checksum, crc, hash, etc) on any computer science reference/website/wikipedia if you want more details. Depending on your game, it may be simpler just to basic deck statistics (number of cards of a specific type). If decks are small, like fewer than 15 cards, you could just number every card and calculate the sum of a deck. There are lots of ways you could go about this but the basic idea is to calculate and record a concise summary of the deck characteristics.