game-editor.com

something is wrong with this function, because sometimes when i run it, my game freezes and crashes. I cant figure out why. it only crashes in some situations where suddenDeath=0;

Code: Select all

int checkWinners()
{
    int firstPlayer;
    int secondPlayer;
    int thirdPlayer;
 
    if(gamePlaying==1)
    {
        switch(suddenDeath)
        {
            case 0:
            switch(amountChar)
            {
                case 2:
                if(collide.playerNo==2)
                {
                    winners[1]=1;
                    winners[2]=2;
                    return 1;
                }
                else
                {
                    winners[1]=2;
                    winners[2]=1;
                    return 1;
                }
 
                case 3:
                if(winners[3]==0)
                {
                    winners[3]=collide.playerNo;
                    return 0;
                }
                else if(winners[2]==0)
                {
                    winners[2]=collide.playerNo;
                    switch(winners[2])
                    {
                        case 1:
                        switch(winners[3])
                        {
                            case 2:
                            winners[1]=3;
                            break;
 
                            case 3:
                            winners[1]=2;
                            break;
                        }
                        break;
 
                        case 2:
                        switch(winners[3])
                        {
                            case 1:
                            winners[1]=3;
                            break;
 
                            case 3:
                            winners[1]=1;
                            break;
                        }
                        break;
 
                        case 3:
                        switch(winners[3])
                        {
                            case 1:
                            winners[1]=2;
                            break;
 
                            case 2:
                            winners[1]=1;
                            break;
                        }
                        break;
                    }
                    return 1;
                }
                break;
 
                case 4:
                if(winners[4]==0)
                {
                    winners[4]=collide.playerNo;
                    return 0;
                }
                else if(winners[3]==0)
                {
                    winners[3]=collide.playerNo;
                    return 0;
                }
                else if(winners[2]==0)
                {
                    winners[2]=collide.playerNo;
                    switch(winners[2])
                    {
                        case 1:
                        switch(winners[3])
                        {
                            case 2:
                            switch(winners[4])
                            {
                                case 3:
                                winners[1]=4;
                                break;
 
                                case 4:
                                winners[1]=3;
                                break;
                            }
                            break;
 
                            case 3:
                            switch(winners[4])
                            {
                                case 2:
                                winners[1]=4;
                                break;
 
                                case 4:
                                winners[1]=2;
                                break;
                            }
                            break;
 
                            case 4:
                            switch(winners[4])
                            {
                                case 2:
                                winners[1]=3;
                                break;
 
                                case 3:
                                winners[1]=2;
                                break;
                            }
                        }
                        break;
 
                        case 2:
                        switch(winners[3])
                        {
                            case 1:
                            switch(winners[4])
                            {
                                case 3:
                                winners[1]=4;
                                break;
 
                                case 4:
                                winners[1]=3;
                                break;
                            }
                            break;
 
                            case 3:
                            switch(winners[4])
                            {
                                case 1:
                                winners[1]=4;
                                break;
 
                                case 4:
                                winners[1]=1;
                                break;
                            }
                            break;
 
                            case 4:
                            switch(winners[4])
                            {
                                case 1:
                                winners[1]=3;
                                break;
 
                                case 3:
                                winners[1]=1;
                                break;
                            }
                            break;
                        }
                        break;
 
                        case 3:
                        switch(winners[3])
                        {
                            case 1:
                            switch(winners[4])
                            {
                                case 2:
                                winners[1]=4;
                                break;
 
                                case 4:
                                winners[1]=2;
                                break;
                            }
                            break;
 
                            case 2:
                            switch(winners[4])
                            {
                                case 1:
                                winners[1]=4;
                                break;
 
                                case 4:
                                winners[1]=1;
                                break;
                            }
                            break;
 
                            case 4:
                            switch(winners[4])
                            {
                                case 1:
                                winners[1]=2;
                                break;
 
                                case 2:
                                winners[1]=1;
                                break;
                            }
                            break;
                        }
                        break;
 
                        case 4:
                        switch(winners[3])
                        {
                            case 1:
                            switch(winners[4])
                            {
                                case 2:
                                winners[1]=3;
                                break;
 
                                case 3:
                                winners[1]=2;
                                break;
                            }
                            break;
 
                            case 2:
                            switch(winners[4])
                            {
                                case 1:
                                winners[1]=3;
                                break;
 
                                case 3:
                                winners[1]=1;
                                break;
                            }
 
                            case 3:
                            switch(winners[4])
                            {
                                case 1:
                                winners[1]=2;
                                break;
 
                                case 2:
                                winners[1]=1;
                                break;
                            }
                        }
                        break;
                    }
                    return 1;
                }
                break;
            }
            break;
 
            case 1:
            firstPlayer=suddenDeathPlayers[4];
            secondPlayer=suddenDeathPlayers[5];
            thirdPlayer=suddenDeathPlayers[6];
            switch(amountChar)
            {
                case 2:
                if(collide.playerNo==secondPlayer)
                {
                    winners[firstSlot]=firstPlayer;
                    winners[secondSlot]=secondPlayer;
                    return 1;
                }
                else if(collide.playerNo==firstPlayer)
                {
                    winners[firstSlot]=secondPlayer;
                    winners[secondSlot]=firstPlayer;
                    return 1;
                }
                else
                {
                    return 0;
                }
 
                case 3:
                if(collide.playerNo==thirdPlayer)
                {
                    if(winners[thirdSlot]==0)
                    {
                        winners[thirdSlot]=thirdPlayer;
                        return 0;
                    }
                    else if(winners[secondSlot]==0)
                    {
                        winners[secondSlot]=thirdPlayer;
                        if(winners[thirdSlot]==secondPlayer)
                        {
                            winners[firstSlot]=firstPlayer;
                        }
                        else if(winners[thirdSlot]==firstPlayer)
                        {
                            winners[firstSlot]=secondPlayer;
                        }
                        return 1;
                    }
                }
                else if(collide.playerNo==secondPlayer)
                {
                    if(winners[thirdSlot]==0)
                    {
                        winners[thirdSlot]=secondPlayer;
                        return 0;
                    }
                    else if(winners[secondSlot]==0)
                    {
                        winners[secondSlot]=secondPlayer;
                        if(winners[thirdSlot]==thirdPlayer)
                        {
                            winners[firstSlot]=firstPlayer;
                        }
                        else if(winners[thirdSlot]==firstPlayer)
                        {
                            winners[firstSlot]=thirdPlayer;
                        }
                        return 1;
                    }
                }
                else if(collide.playerNo==firstPlayer)
                {
                    if(winners[thirdSlot]==0)
                    {
                        winners[thirdSlot]=firstPlayer;
                        return 0;
                    }
                    else if(winners[secondSlot]==0)
                    {
                        winners[secondSlot]=firstPlayer;
                        if(winners[thirdSlot]==secondPlayer)
                        {
                            winners[firstSlot]=thirdPlayer;
                        }
                        else if(winners[thirdSlot]==thirdPlayer)
                        {
                            winners[firstSlot]=secondPlayer;
                        }
                        return 1;
                    }
                }
            }
            break;
        }
    }
    return 1;
}

That is a lot of code to sort through especially since we aren't given the actual setup or what the variables are used for. What is the size of the winners array? You seem to never access winner[0] and you do winner[4], which if it is an array size 4, could explain the crash.

By the way, what is the code even trying to do? I ask because it looks like there is a lot of unnecessary code in there.

Its not that. Winners is size 5, and winners[0] is reserved for somthing else

And the code is putting the person who just died's playerNo in the next slot. If a certain slot is full, it puts it in the mext one

All you are doing is storing the order the players died in? If so here's one way of doing just that (you could also use a variable to determine the number of players left or dead, and use that instead of a loop).

Code: Select all

void
insert_player ()
{
  int i;
  for(i=1;i<5;i++)
  {
    if(winners[i]==0) // no player
    {
        winners[i]=player_number;
        break;
    }
  }
}

Normally I would go through and try to find the problem in your code, but it is very long and way to many conditions considering I don't have the setup. I recommend rewriting it, due to the triple nested switch statements, mass number of conditions, confusing break points, and several return statements.

Nevermind it wasn't that function, but yes i will rewrite that one i know its way longer than it needs to be