How to refactor deeply nested functions? - if-statement

Question

My code currently looks like this:
If (case = 1)
{
If (option = 1)
{
If (otherOption = 1)
;do something
else if (otherOption = 2)
;do something
else if (otherOption = 3)
;do something
}
else
{
If (otherOption = 1)
;do something
else if (otherOption = 2)
;do something
else if (otherOption = 3)
;do something
}
}
else if (case = 2)
{
If (option = 1)
{
If (otherOption = 1)
;do something
else if (otherOption = 2)
;do something
else if (otherOption = 3)
;do something
}
else
{
If (otherOption = 1)
;do something
else if (otherOption = 2)
;do something
else if (otherOption = 3)
;do something
}
}
else if (case = 3)
{
If (option = 1)
{
If (otherOption = 1)
;do something
else if (otherOption = 2)
;do something
else if (otherOption = 3)
;do something
}
else
{
If (otherOption = 1)
;do something
else if (otherOption = 2)
;do something
else if (otherOption = 3)
;do something
}
}
Obviously terrible and difficult to maintain. I want to add yet another super If statement on top of this, which splits this tree 6 times. Each ;do something does one line of code.
Any help on how to refactor this monstrosity? I've written a lot of code that looks like this and I dread working with it every time. I need a new way to approach these problems. Extending the functionality of this code requires a lot of work.

Answer 1

Even if you didn't specify the context of your application, it seems a scenario that could take advantage from the application of Strategy Pattern.
The code you posted can be settled to act as the Context object with the responsibility of control the higher level condition of your outer if-else statement.
Within every block of if-else statement, a particular behaviour can be loaded using a a ConcreteStrategy object (that usually implements a Strategy interface).
This pattern can be repeated for inner if-else blocks.
Example
Consider a game in which a Character moves around a 2D-map. Depending of its life indicator (e.g 0-200), it can moves of 2,5,8 tiles if he is,respectively,in a tired, ok or a super state.
The Character object acts like the "Context of the Strategy Pattern and he has the responsability of which MoveStrategy is correct for the situation.
Putting of life the correct MoveStrategy object and calling by forwarding the method move() throght the move() method of Character.
A hint for a Java implementation of the example:
public class Character{
private int life=100;
private int x=0
private int y=0;
private MoveStrategy strategy=new DefaultStrategy();
public int getLife(){
return life;
}
public void setLife(int value){
this.life=value;
}
public void move(){
if(life<30)
strategy=new TiredStrategy();
else if(life > 100)
strategy=new SuperStrategy();
else
strategy=new DefaultStrategy();
strategy.move();
}
}
public interface MoveStrategy{
public abstract void move();
}
public DefaultStrategy implements MoveStrategy{
public void move(){
System.out.println("Move character of 5 tiles");
}
}
public TiredStrategy implements MoveStrategy{
public void move(){
System.out.println("Move character of 2 tiles");
}
}
public SuperStrategy implements MoveStrategy{
public void move(){
System.out.println("Move character of 8 tiles");
}
}