Increase difficulty based on score

Just a quick note about naming:

bool Increased100500 = false;
bool Increased5001500 = false;
bool Increased15003000 = false;

Please, don't do that. I mean, yeah, private fields should be camelCase in the first place, but that chunk of numbers is fairly annoying, and it encodes your game logic into an identifier.

If you wanted to change your levels, let alone making them configurable, then what's 100500 going to tell the maintainer?

Consider using names like this instead:

var increasedLevel1 = false;
var increasedLevel2 = false;
var increasedLevel3 = false;

That's still encoding 3 difficulty levels into the identifiers, but at least the thresholds aren't part of the variables' names, so it's a start.

You don't talk about if the score can decrease or if it is possible for the score to jump over one of the difficulty ranges. If neither of these things are possible, the logic to set the difficulty can become very simple by using an enum.

enum Difficultly { Normal, Hard, Harder, Hardest }

class State
{
  private Difficultly _currentDifficultly = Difficultly.Normal;
  private int _score = 0;

  public void UpdateDifficulty()
  {
    switch(_currentDifficulty)
    {
      case Normal:
        if (_score  >= 100)
        {
          _currentDifficulty = Difficulty.Hard;
        }
        break;
      case Hard:
        if (_score  >= 500)
        {
          _currentDifficulty = Difficulty.Harder;
        }
        break;
      //...
    }
  }
}

However, as you can see, this gets very repetitive very fast. An alternative would be to construct a table that defines the data points.

Dictionary<Difficulty, Tuple<int, Difficulty>> _difficultyTransitions = new Dictionary<Difficulty, Tuple<int, Difficulty>>()
{
  { Difficulty.Normal, new Tuple<int, Difficulty>(100, Difficulty.Hard)},
  { Difficulty.Hard, new Tuple<int, Difficulty>(500, Difficulty.Harder)},
  { Difficulty.Harder, new Tuple<int, Difficulty>(1500, Difficulty.Hardest)},
  { Difficulty.Hardest, new Tuple<int, Difficulty>(int.MaxValue, Difficulty.Hardest)},
};

public void UpdateDifficulty()
{
  var transition = difficultyTransitions[_currentDifficulty];
  if (_score >= transition.Item1)
  {
    _currentDifficulty = transition.Item2;
  }
}

If Score cannot jump suddenly in the levels, for example after Score=50 it cannot jump to Score=550, then you could simplify by using half-ranges in the if statements, so instead of Score >= X && Score <= X + C you could use just Score >= X, like this:

void IncreaseScore()
{
    if (Score >= 100 && !Increased100500)
    {
        Increase();
        Increased100500 = true;
    } 
    else if (Score >= 500 && !Increased5001500)
    {
        Increase();
        Increased5001500 = true;
    } 
    else if (Score >= 1500 && !Increased15003000)
    {
        Increase();
        Increased15003000 = true;
    } 
}

But this is just treating the symptoms, not the real problem. It's not good that you need 3 state variables Increased100500, Increased5001500, and Increased15003000, and the hardcoded constants 100, 500, 1500 to keep track of this.

It would be better to refactor somehow without using those boolean variables at all. For example:

private const int[] thresholds = {100, 500, 1500};
private const HashSet<int> passedThresholds = new HashSet<int>();

void IncreaseScore()
{
    for (int threshold : thresholds)
    {
        if (Score >= threshold && !passedThresholds.Contains(threshold))
        {
            passedThresholds.add(threshold);
            Increase();
            break;
        }
    }
}

The behavior of this code is equivalent, and you don't need so many boolean variables to track the state. The increaseScore method doesn't need to know the exact values of the thresholds either, which is a good thing. And you can easily change the thresholds, simply in the declaration of thresholds, and without editing variable names.

A riff on @200_success answer

// value is the base-score for that level
public enum Difficulty {
    Beginner = 0,
    Easy = 100,
    Medium = 500,
    Hard = 1500
}

void IncreaseScore() // yeah, needs a different name
{
    Difficulty NewDifficulty = (Score <   Difficulty.Easy) ? Difficulty.Beginner
                      : (Score <=  Difficulty.Medium) ? Difficulty.Easy
                      : (Score <= Difficulty.Hard) ? Difficulty.Medium
                                        : Difficulty.Hard;
    // One-way ratchet: difficulty can only increase, even if the
    // score subsequently drops.
    if (NewDifficulty < CurrentDifficulty)
    {
        CurrentDifficulty = NewDifficulty;
    }
}

• Defines levels for use everywhere.
• Encapsulates the actual values associated w/ the levels
• Useful throughout the application where ever the score-level needs to be used
• Explicitly defines an initial state
• Eliminates all magic numbers as seen in several other answers
• No need for intermediate ints - which were essentially redefining the difficulty values.

I am not fond of the hardcoding since that will make it difficult to change your score thresholds later.This rules out Enum's as well. I liked Janos's second answer best, but that means storing a copy of the thresholds in a hash. In addition it will continue to loop through every threshold after the max difficulty is reached just to do nothing.

The following uses one list, handles level jumping, and once max difficulty is reached it short circuits as quickly as possible.

Initial variable declarations are only to illustrate type/expectation. Score, Difficulty, and the threshold list should be wrapped up nicely somewhere else in a static Singleton managing game state. And the thresholds need to come out of a configuration store somewhere so you don't need to recompile your game to change your mind later.

The key to this approach is that the difficulty is the index into the threshold list to determine the next increase. I did assume that you wouldn't be going backwards like the other solutions. Once difficulty level is out of bounds you know you have nothing left to check and are at max level.

int currentScore = 0; 
int currentDifficulty = 0;
List<int> difficultyThresholds = new List<int>() { 100, 500, 1500 };

void DifficultySlider()
{
   if (currentDifficulty >= difficultyThresholds.Count)
   {
      return;
   }

   while (currentScore >= difficultyThresholds[currentDifficulty])
   {
      currentDifficulty += 1;
      if (currentDifficulty >= difficultyThresholds.Count)
      {
         return;
      }
   }
}

Checking in reverse order will catch any possible diffuculty jumps (ie from easy straight to insane) as well as any possible negative changes in score.

enum Difficulty { Easy = 0, Medium, Hard, Insane, Deathwish }
Difficulty currentDifficulty;

void UpdateDifficulty(int _score)
{
    if(_score >= 3000)
    {
        currentDifficulty = Difficulty.Deathwish;
    }
    else if(_score >= 1500)
    {
        currentDifficulty = Difficulty.Insane;
    }
    else if(_score >= 1000)
    {
        currentDifficulty = Difficulty.Hard;
    }
    else if(_score >= 500)
    {
        currentDifficulty = Difficulty.Medium;
    }
    else
    {
        currentDifficulty = Difficulty.Easy;
    }
}

I don't use C# but took this as a chance to learn some of it... Tested it first on Progress 4GL and then made the C# version (quite ugly one).

My idea was to use modulo to find out if it's needed to increase the difficulty:

score % thresholds[x] < score

That way there's no need to hardcode the IF-clauses (only need to hardcode the thresholds).

Ideone link: http://ideone.com/JM9Nj1

using System;

public class Test
{
    public static void Main()
    {
        // your code goes here
        int[] thresholds = new int[4] {100, 500, 1000, 1500};
        int difficulty = 0;
        int score = 0;

        for (score = 0; score <= 3000; score++) {
            for (int x = 0; x < thresholds.Length; x++)
            {
                if (score % thresholds[x] < score && difficulty < x + 1) { 
                    difficulty = x + 1;
                    Console.WriteLine("Score: " + score + " Threshold: " + thresholds[x] + " Difficulty: " + difficulty + " Increased difficulty!");
                    break; 
                }
            }
        }
    }
}