Oneindige loop? :/

[Frats]

Het programma blijft continue hangen in het dikgedrukte stuk en ik heb me er eergisteren blind op gestaard, maar volgensmij zie ik iets heel simpels over het hoofd ofzo :/

card[] is een globale array met 7 kaart-typen als keys en de aantallen als velden
hand[][] is een twee dimensionale array met spelers X kaarten (dus bijv: hand[1][4] is de vierde kaart van de eerste speler)

Hij deelt een aantal kaarten rond, maar na een tijdje stopt hij ineens, en kan dus niet vinden waarom hij blijft hangen in dat While loopje...

Ik hoop dat iemand me kan helpen.

/*
* Main game process. will setup a new game and activate it.
*
*/
Process start_game()
Private
       total_cards    = 24;     // total number of cards in the game
       current_player = 1;      // the current players we are dealing to
       current_card   = 1;      // the current round of cards we're dealing
       i              = 0;      // general purpose counter
Begin

     // game setup: ready all cards
     card[ 1 ] = 4;
     card[ 2 ] = 4;
     card[ 3 ] = 4;
     card[ 4 ] = 4;
     card[ 5 ] = 4;
     card[ 6 ] = 3;
     card[ 7 ] = 1;

     // ready the hands of each player
     While ( total_cards > 0 )
           // get a random card and add it to this hand (removing it from card, too)
           hand[ current_player ][ current_card ] = get_random_card();
           // if not all players have an equal number of cards
           If ( current_player < players )
              // advance to the next player
              current_player++;
           Else
               // otherwise, start at the first player
               current_player = 1;
               // and deal the next series of cards.
               current_card++;
           End;
           // note one card gone
           total_cards--;
     End;
End;

/**
* Remove a card from the card list, and return its type
*/
Function get_random_card ()
Private
       number_cards = 0;   // total number of cards
       i = 0;              // general purpose counter
       card_to_remove = 0; // the card number to remove
       type_to_remove = 0; // the type of the card we've removed
Begin

     // count the number of cards
     For ( i = 1; i <= 7 ; i++ )
         // add the number of this card remaining.
          number_cards += card[ i ];
     End;

     // get a random number; this is the card to remove.
     card_to_remove = rand ( 1, number_cards );

     // find the selected card in the list
     i = 1;
[b]
     While ( card_to_remove > 0 )
           // consider this the card to use.
           type_to_remove = i;
           // reduce the card number by the number of cards of this type
           card_to_remove -= card[ i ];        
     End;
[/b]
     // we know the card type to remove.
     // remove one card of that type; then return it's type value.
     card[ type_to_remove ]--;
     return type_to_remove;
End;

 

[Tha Devil]

Welke taal betreft het hier? Dan kan ik je vraag naar de juiste sectie verplaatsen.

Het lijkt op iets van VB.

 

[Frats]

Tis Fenix, en ik betwijfel of jullie daar een sectie voor hebben

Maar de syntax opzich is vrij simpel en het probleem is ook niet taalgebonden, dus ik hoopte dat jullie ook zonder kennis van de taal even konden kijken

 

[CoD_NL]

     // find the selected card in the list
     i = 1;

     While ( card_to_remove > 0 )
           // consider this the card to use.
           type_to_remove = i;
           // reduce the card number by the number of cards of this type
           card_to_remove -= card[ i ];        
     End;

Ik snap dit stukje niet helemaal... ik weet niet of het iets met je bug te maken heeft, maar je geeft in het commentaar aan dat je de geselecteerde kaart gaat zoeken, maar de waarde van i verandert niet meer tijdens de rest van de functie ?

Hoe ik je code nu zie komt dit op hetzelfde neer als het onderstaande:

while( (card_to_remove -= card[1]) > 0)
   type_to_remove = 1;

En even later gebruik je de waarde van type_to_remove voor het onderstaande stukje code:

 card[ type_to_remove ]--;
     return type_to_remove;

type_to_remove behoudt de hele tijd toch dezelfde waarde ?


edit: dit is volgens mij ook de bug die je hebt. (al is hij hier niet oneindig)

// hier stel je de waarde van card[1] in
card[1] = 4;

En op het einde van de functie heb je het onderstaande staan:

card[ type_to_remove ]--;

Nadat deze functie een aantal keer is uitgevoerd, heeft card[1] een waarde die lager is dan 0, en daardoor krijg je een andere berekening. (hij verhoogt de variabele dan ipv dat ie hem verlaagt)

 

[Frats]

Dat was inderdaad de bug...

Bedankt; ik hoopte al dat een extra paar ogen het verschil zou maken

Zodra card[ 1 ] op 0 stond sprong hij op oneindige loop, omdat i niet verhoogd werd, bleef hij steeds -0 doen, tot het resultaat kleiner was dan 0...

Zoiets kleins; blah. Ahwell, kan ik weer verder!

Nogmaals bedankt

 

[CoD_NL]

Ja, die hele kleine foutjes zijn niet altijd makkelijk te vinden. (vooral als je zelf de aanname maakt dat die code gewoon goed moet zijn )

Maar ik neem aan dat de taal Fenix wel een debugger heeft ?

 

[Frats]

Hij heeft een console/debugger, maar daar kwam ik ook gisteravond pas achter

Documentatie is niet echt alles :/