hjælp os! Handler problemer

Jeg er godt klar over at nogle ting måske kan laves på enklere måder, men vi er alle newbees inden for c++!

Inden jeg kaster mig over koden for alvor kunne det være rart om de mest banale warnings/fejl var fjernet: f.ex:
if(w='j')
Burde nok være if(w=='j'), så kik lige en gang på jeres warnings (og enabel så mange som muligt).
Dernæst ville det være rart at vide hvori fejlen består.

Hvad er der galt - hvad er det der ikke virker?

indsæt nogle passende print sætninger i handler og de funktioner i ikke kommer ind i.

måske er der nogle case der ikke er håndteret, lav den default i alle switch og udskriv en passende meddelelse der, fx. "fatal fejl, hvordan kommer man i denne default nr. X" eller "du må træffe et valg 1,2,3,4 eller 5".

I har også en masse if'er der lige så godt kunne være switches, med en default, det letter overblikket.

Øvrige I vil blive spurgt om:
int temp[11]={NULL} ;
void main

okay... jeg vi har kigget lidt på jeres råd, og tak fordi i gider at kigge på det!. Problemet er at vi er nybegyndere inden for c++ og mange af de warnings der dukker op, ved vi ikke hvordan der skal klares! Vi har kigget på koden hele dagen, og er nu nået frem til det minimale antal warnings vi kan finde ud af at få det kuttet ned til!:
#include <stdio.h>
#include <iostream.h>
#include <conio.h>
#include <stdlib.h>
#include <time.h>
#include <fstream.h>                        /* deklarerer at der skal kunne laves
                                                    indput og output til filer*/
#include <io.h>
#include <string.h>
#include <windows.h>
#define TERNINGER 5
#define ANTAL_OJNE 6

///////////////////////////////////////////////////////////////////////////////
// klassen bgf - bruger grænseflade
////////////////////////////////////////////////////////////////////////////////

class bgf
{
    public:
  bool logon(bool b1);
    void viewhighscore(bool b1);
  void viewTop10point();
  void viewTop10navn();
  bool spiltype_menu();
  int afslutningsmenu();
  void SingleSpil();
  void MultiSpil();
  void handler();

}bgf1;

///////////////////////////////////////////////////////////////////////////////
// klassen blokken
////////////////////////////////////////////////////////////////////////////////

class blokken
{
    public:
  blokken();
  int blok(char pointvalg);
  char pointvalg;
  int terningervardi[TERNINGER];
  int total;
  int bonus;
  int eter;
    int toer;
    int trer;
    int firer;
  int femer;
  int sekser;
    int et_par;
    int to_par;
  int tre_ens;
  int fire_ens;
  int den_lille;
  int den_store;
  int fuldt_hus;
  int yatzy;
  int chancen;
  void FraSpil(bool b1);
    void TilSpil(bool b1);
  void resetblok();
}blok1,blok2;

blokken::blokken()
{
    eter=-1;
    toer=-1;
    trer=-1;
    firer=-1;
  femer=-1;
  sekser=-1;
    et_par=-1;
    to_par=-1;
  tre_ens=-1;
  fire_ens=-1;
  den_lille=-1;
  den_store=-1;
  fuldt_hus=-1;
  yatzy=-1;
  chancen=-1;
}

///////////////////////////////////////////////////////////////////////////////
// klassen Highscore
////////////////////////////////////////////////////////////////////////////////

class highscorer
{
    public:
    char top10[10][255];
    char charnavn[10][252];
    char ChartalAr[10][4];
    void Algorithm (int *a, int lo, int hi);
    void printVal (int *ar, int index);
    void sorter (int *a, int *b);
    void OpdaterTop10(char *brug, int *p);
    void SorterTop10Navn ();
    void SletFiler();
    void HighscorePoint();
}high1,high2;

///////////////////////////////////////////////////////////////////////////////
// klassen bruger
////////////////////////////////////////////////////////////////////////////////

class bruger
{
    public:
  bruger();
    int single[17];
    int multip1[17];
    int multip2[17];
    int highscore[10];
  char navn[225];
  bool hentdata(char brugertest[]);
  void gembruger(char nybruger[]);
}bruger1,bruger2;

bruger::bruger()
{
  for (int ap=0; ap < 17; ap++)
  {
        single[ap]=-1;
      multip1[ap]=-1;
      multip2[ap]=-1;

      if (ap < 10)
      {
          highscore[ap]=(0);
      }
    }
}

///////////////////////////////////////////////////////////////////////////////
// klassen bæger
////////////////////////////////////////////////////////////////////////////////

class baeger
{
    public:

    void counter();
    void terning();
    void rysteterning(bool t1, bool t2, bool t3, bool t4, bool t5);
}baeger1;

class terning
{
    public:
    int terningervardier[TERNINGER];
}terning1;

//////////////////////////////////////////////////////////////////////////////
// ***Funktioner til highscore***
////////////////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////////////////
//
//  Funktion         : highscorer::sorter
//
//  Input            : (int *a, int *b)  //int a[10], int b[1]
//  Output            :
//  Globale par    : charnavn, CharnavnAr
//
//  Beskrivelse    : Til sortering af  2 int arrays
//
///////////////////////////////////////////////////////////////////////////////
void highscorer::sorter (int *a, int *b)
{

  int temp[11]={NULL} ;

    for (int n=0; n < 10 ; n++)
  {
      temp[n]=a[n];
  }
  temp[10]=b[0];

  printVal (temp, sizeof (temp) / sizeof (int));
  Algorithm (temp, 0, 10);
  printVal (temp, sizeof (temp) / sizeof (int));

  for (int n=0; n <10;n++)
  {
          a[n]=temp[n+1];
  }
}
///////////////////////////////////////////////////////////////////////////////
//
//  Funktion         :  highscorer::HighscorePoint()
//
//  Input            :
//  Output            :
//  Globale par    :  top10[n]
//
//  Beskrivelse    :  Indlæser top10 ind i top10[][]
//
///////////////////////////////////////////////////////////////////////////////

void highscorer::HighscorePoint()
{
    ifstream HentTop10;
      HentTop10.open ("top10.txt");
      for (int n=0;n<10;n++)
      {
        HentTop10.getline(top10[n],sizeof(top10[n]));
        }
  HentTop10.close();
}

///////////////////////////////////////////////////////////////////////////////
//
//  Funktion         :highscorer::OpdaterTop10
//
//  Input            : (char *brug, int *p) brugernavn, point
//  Output            :
//  Globale par    :ChartalAr charnavn
//
//  Beskrivelse    :indsætter brugernavn og point fra færdig spil ind, sorter
//                        det og skriver top10.txt
//
///////////////////////////////////////////////////////////////////////////////

void highscorer::OpdaterTop10(char *brug, int *p)
{
    char chartal[3];
    int inttal[10];
    int placering=0;
    HighscorePoint();
    for (int m=0;m<10;m++)
      {
            for(int n=0;n<255;n++)
        {
          if (n<3)
          {
              chartal[n]=top10[m][n];
          }
              else
          {
              charnavn[m][n-3]=top10[m][n];
          }
      }
              inttal[m] = atoi(chartal);
      }
        sorter(inttal,p);
        for (;placering<11;placering++)
    {
    if (inttal[placering]==p[0])
      {
        break;
      }
    }
    if(placering<11)
      {
      for(int n=0;n<placering;n++)
          {
        for(int h=0;h<252;h++)
            {
                    charnavn[n][h]=charnavn[n+1][h];
            }
        }
              char temp[252]={NULL};
            strcpy(temp,brug);
              strcpy(brug," ");
          strcat(brug,temp);
          for(int j=0;j<252;j++)
            {
                charnavn[placering][j]=brug[j];
            }
      }

      ofstream file;
        file.open( "top10.txt");
      file <<" ";
      file.close();
      file.open( "top10.txt", ios::out | ios::in );

      for (int n=0;n<10;n++)
          {
        if ((inttal[n]<10) && (inttal[n]<100))
            {
                file << "00" << inttal[n] <<charnavn[n] <<"\n" ;
            }
            else if (inttal[n]<100)
                {
                  file << "0" <<inttal[n]<< charnavn[n] <<"\n";
              }
              else
                  {
                      file << inttal[n]<< charnavn[n] <<"\n";
                  }
    }
file.close();
}
///////////////////////////////////////////////////////////////////////////////
//
//  Funktion         :SorterTop10Navn()
//
//  Input            :
//  Output            :
//  Globale par    : charnavn[] og ChartalAr[]
//
//  Beskrivelse    :indlæser fra top10.txt i top10[][] sorter det efter navn
//                        i charnavn[] og ChartalAr[]
//
///////////////////////////////////////////////////////////////////////////////

void highscorer::SorterTop10Navn()
{
HighscorePoint();
    for (int m=0;m<10;m++)
  {
        for(int n=0;n<255;n++)
        {
          if (n<3)
          {
            ChartalAr[m][n]=top10[m][n];
                ChartalAr[m][n+1]='\0';
          }
          else
              {
                  charnavn[m][n-3]=top10[m][n];
              }
      }
    }
  for (int a=0;a<10;a++)
          {
          for (int b = 9 ;b > a ; b--)
          {
          if (charnavn[a][1] > charnavn[b][1])
              {
              char temp1[252]="";
                strcpy(temp1,charnavn[a]);
                strcpy(charnavn[a],charnavn[b]);
                strcpy(charnavn[b],temp1);
                  char temp2[3]="";
                  for (int m=0;m<3;m++)
                {
                  temp2[m]=ChartalAr[a][m];
                    ChartalAr[a][m]=ChartalAr[b][m];
                    ChartalAr[b][m]=temp2[m];
              }
            }
          if (charnavn[a][1] == charnavn[b][1])
          {
              for(int c=2;c<250;c++)
                {
                  if (charnavn[a][c] > charnavn[b][c])
                      {
                        char temp1[252]="";
                        strcpy(temp1,charnavn[a]);
                        strcpy(charnavn[a],charnavn[b]);
                        strcpy(charnavn[b],temp1);
                        char temp2[3]="";
                      for (int m=0;m<3;m++)
                        {
                          temp2[m]=ChartalAr[a][m];
                            ChartalAr[a][m]=ChartalAr[b][m];
                            ChartalAr[b][m]=temp2[m];
                    }
                  break;
                  }
                      if (charnavn[a][c] < charnavn[b][c])
                  {
                      break;
                  }
              }
          }
          }
      }
}
///////////////////////////////////////////////////////////////////////////////
//
//  Funktion         : highscorer::SletFiler()
//
//  Input            :
//  Output            :
//  Globale par    :
//
//  Beskrivelse    : Sletter top10.txt og highscore.txt
//
///////////////////////////////////////////////////////////////////////////////
void highscorer::SletFiler()
{
      char Top10[13]="top10.txt";
    remove(Top10);
      ofstream fil1;
    fil1.open ("highscore.txt");
    fil1 << "¤";
    fil1.close();
}

///////////////////////////////////////////////////////////////////////////////
//
//  Funktion         : highscorer::Algorithm
//
//  Input            : int *a, int lo, int hi
//  Output            :
//  Globale par    :
//
//  Beskrivelse    : Sletter top10.txt og highscore.txt
//
///////////////////////////////////////////////////////////////////////////////

void highscorer::Algorithm (int *a, int lo, int hi)
{
  int i = lo;
  int j = hi;
  int h;
  int x = a[(lo + hi) / 2];

  do
  {
      while (a[i] < x)
          {
          i++;
          }
        while (a[j] > x)
          {
            j--;
      }
          if (i <= j)
      {
        h = a[i];
        a[i] = a[j];
        a[j] = h;
        i++;
        j--;
      }
  }
  while (i <= j);

  if (lo < j)
      {
          Algorithm(a, lo, j);
      }
  if (i < hi)
      {
          Algorithm(a, i, hi);
        }
}

void highscorer::printVal (int *ar, int index)
{
    if (index == 0)
  {
      return;
  }
  printVal (ar, index - 1);

}
///////////////////////////////////////////////////////////////////////////////
// ***Funktioner til baegeret***
////////////////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////////////////
//
//  Funktion         : baeger::counter()
//
//  Input            :
//  Output            :
//  Globale par    :
//
//  Beskrivelse    : Bliver brugt til at ryste terninger, og samtidigt tælle
//                  hvor mange ture spilleren har tilbage.
///////////////////////////////////////////////////////////////////////////////

void baeger::counter()
{
  char tast;

  bool t1=true;
  bool t2=true;
  bool t3=true;
  bool t4=true;
  bool t5=true;
  baeger1.rysteterning(t1,t2,t3,t4,t5);
    for(int n=4;n>0;n--)
  {
      cout << "Du har:" << n << " ture tilbage\n";
      do
      {
        tast=getch();
      if (tast == '1')
            {
                if(t1) t1=false;
              else t1=true;
            tast='\0';
            }
    if (tast == '2')
    {
            if(t2) t2=false;
        else t2=true;
        tast='\0';
    }
    if (tast == '3')
    {
            if(t3) t3=false;
        else t3=true;
        tast='\0';
    }
    if (tast == '4')
    {
            if(t4) t4=false;
        else t4=true;
        tast='\0';
    }
    if (tast == '5')
    {
            if(t5) t5=false;
        else t1=true;
        tast='\0';
    }

  }
  while(tast =='\0');

          baeger1.rysteterning(t1,t2,t3,t4,t5);
      for(int n=1;n<TERNINGER+1;n++)
  {
        cout << terning1.terningervardier[n] << " ";
  }
      cout << "\n";
  }

}

///////////////////////////////////////////////////////////////////////////////
//
//  Funktion         : void terning::rysteterning()
//
//  Input            : (bool t1, bool t2, bool t3, bool t4, bool t5)
//  Output            :
//  Globale par    :
//
//  Beskrivelse    : Bliver brugt brugt til at holde/slippe terningerne
//
///////////////////////////////////////////////////////////////////////////////

void baeger::rysteterning(bool t1=true, bool t2=true, bool t3=true,
bool t4=true, bool t5=true)
{
randomize();
    if(t1)
    {
        terning1.terningervardier[1]=(random(ANTAL_OJNE)+1);
    }
    if(t2)
    {
        terning1.terningervardier[2]=(random(ANTAL_OJNE)+1);
    }
    if(t3)
    {
        terning1.terningervardier[3]=(random(ANTAL_OJNE)+1);
    }
    if(t4)
    {
        terning1.terningervardier[4]=(random(ANTAL_OJNE)+1);
    }
    if(t5)
    {
        terning1.terningervardier[5]=(random(ANTAL_OJNE)+1);
    }
}

////////////////////////////////////////////////////////////////////////////////
// ***Funktioner til brugeren***
////////////////////////////////////////////////////////////////////////////////

///////////////////////////////////////////////////////////////////////////////
//
//  Funktion         : bruger::hentdata
//
//  Input            : char brugertest[]
//  Output            : true, false
//  Globale par    :
//
//  Beskrivelse    : Søger highscore.txt for navn, indlæser hvis den eksisterer.
//
///////////////////////////////////////////////////////////////////////////////

bool bruger::hentdata(char brugertest[])
{
    char temp[256]={NULL};
    bool godt=true;
    ifstream hentdata;
    hentdata.open ("highscore.txt");

    while (hentdata >> temp)
    {
      int x=0;
          for(;brugertest[x];x++);
            for(int n=0; n<=x;n++)
        {
          if (temp[n]==brugertest[n])
          {
              godt = true;
            if (n==x)
        {

            char et[2]={NULL};
            char to[78]={NULL};
              char *p1;
          p1=&to[24];

          char tre[78]={NULL};
          char *p2;
          p2=&tre[24];
          char fire[78]={NULL};
          char *p3;
          p3=&fire[24];
          char fem[78]={NULL};
          char *p4;
          p4=&fem[6];

            hentdata.getline(et,sizeof(et));
              hentdata.getline(to,sizeof(to));
          hentdata.getline(tre,sizeof(tre));
          hentdata.getline(fire,sizeof(fire));
          hentdata.getline(fem,sizeof(fem));
          int arrayplads=0 ;
          int tur=0 ;
          for (;tur < 17 ;arrayplads++, p1=p1+3,tur++ )
            {
                single[arrayplads]=atoi(p1);
            }
            tur=0;
                arrayplads=0;
            for ( ; tur < 17 ;arrayplads++,p2=p2+3,tur++ )
                {
                    multip1[arrayplads]=atoi(p2);
                  }
            tur=0;
            arrayplads=0;
            for (; tur < 17 ;arrayplads++ ,p3=p3+3,tur++ )
            {
                multip2[arrayplads]=atoi(p3);
            }
            tur=0;
            arrayplads=0;
            for ( ; tur < 10 ;arrayplads++ )
            {
                highscore[arrayplads]=atoi(p4);
                p4++ ;
                p4++ ;
                p4++ ;
              p4++ ;
                tur++;
            }
        return godt;
        }
      }
      else
          {
                  godt = false;
              break;
            }
      }

    }
return godt;
}

///////////////////////////////////////////////////////////////////////////////
//
//  Funktion         : bruger::gembruger
//
//  Input            : char nybruger
//  Output            :
//  Globale par    :
//
//  Beskrivelse    :bruges til at gemme bruger info
//
///////////////////////////////////////////////////////////////////////////////
void bruger::gembruger(char nybruger[])
{
    ofstream fil;
    fil.open( "highscore.txt", ios::out | ios::in | ios::app);

    if ( !fil )
  return;
    fil << "\n" ;
    fil << "brugernavn" << " ";
    fil << nybruger << "\n";
    fil << "savegame_single_playdata" << " ";  // udskriver "..." og et mellemrum

    int ap=0;
    for (;ap < 17; ap++)
    {
        if ((single[ap] < 0)&& ( single[ap] < 10 ) )
      {
          fil << single[ap] << " " ;
      }
      else if(single[ap] < 10)
          {
              fil << "0" << single[ap] << " " ;
        }
        else
            {
                fil << single[ap] << " ";
            }
}
fil << "\n" << "savegame_Vir_pl_own_data" << " " ;
ap=0;
for (;ap < 17; ap++)
{
    if ((multip1[ap] < 0)&& ( multip1[ap] < 10 ) )
      {
          fil << multip1[ap] << " " ;
      }
      else if(multip1[ap] < 10)
          {
              fil << "0" << multip1[ap] << " " ;
        }
        else
            {
                fil << multip1[ap] << " ";
            }
}
fil << "\n" << "savegame_vir_pl_vip_data" << " " ;
ap=0;
for (;ap < 17; ap++)
{
    if ((multip2[ap] < 0)&& ( multip2[ap] < 10 ) )
      {
            fil << multip2[ap] << " " ;
      }
      else if(multip2[ap] < 10)
          {
              fil << "0" << multip2[ap] << " " ;
        }
        else
            {
                fil << multip2[ap] << " ";
            }
}
fil << "\n" << "top_10" << " ";

ap=0;
for (;ap < 10; ap++)
{
    if ((highscore[ap]) < 100 && (highscore[ap] < 10 ) )
      {
      fil << "00" << highscore[ap] << " ";
  }
      else if (highscore[ap] < 10)
      {
          fil << "0" << highscore[ap] << " ";
      }
          else
            {
              fil << highscore[ap] << " ";
        }
}
    fil.close();
}

///////////////////////////////////////////////////////////////////////////////
// ***Funktioner til Terningen***
// Terningen har ikke selv nogle funktioner, ud over at eksistere
////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////
/// ***funktioner for blokken***
////////////////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////////////////
//
//  Funktion         : blokken::blok
//
//  Input            : char
//  Output            :
//  Globale par    :
//
//  Beskrivelse    : Styrer regler for blokken, og indeholder blokkens værdier
//
///////////////////////////////////////////////////////////////////////////////

blokken::blok(char pointvalg='0')
{
    int et=0;
    int to=0;
    int tre=0;
    int fire=0;
    int fem=0;
    int seks=0;


for (int n=1;n<TERNINGER+1;n++)
    {
      if (terningervardi[n]==1) et++;
      if (terningervardi[n]==2) to++;
      if (terningervardi[n]==3) tre++;
      if (terningervardi[n]==4) fire++;
      if (terningervardi[n]==5) fem++;
      if (terningervardi[n]==6) seks++;

  }

        do
      {
          pointvalg=getch();
        }
      while ((pointvalg !='a')&&(pointvalg !='b')&&(pointvalg !='c')
      &&(pointvalg !='d')&&(pointvalg !='e')&&(pointvalg !='f')
      &&(pointvalg !='g')&&(pointvalg !='h')&&(pointvalg !='i')
      &&(pointvalg !='j')&&(pointvalg !='k')&&(pointvalg !='l')
      &&(pointvalg !='m')&&(pointvalg !='n')&&(pointvalg !='o')
      &&(pointvalg !='p'));

    switch(pointvalg)
    {
      case 'a':
      {
        if(eter!=-1)
        {
            break;
        }
        eter=et;
        cout << eter;
      break;
      }
        case 'b':
      {
        if(toer!=-1)
        {
            break;
        }
        toer=to*2;
        cout << toer;
      break;
      }
        case 'c':
      {
        if(trer!=-1)
        {
              break;
        }
        trer=tre*3;
        cout << trer;
      break;
      }
        case 'd':
      {
        if(firer!=-1)
        {
            break;
        }
        firer=fire*4;
        cout << firer;
      break;
      }

      case 'e':
      {
        if(femer!=-1)
        {
            break;
        }
        femer=fem*5;
        cout << femer;
      break;
      }
        case 'f':
      {
        if(sekser!=-1)
        {
            break;
        }
        sekser=seks*6;
        cout << sekser;
      break;
      }
        case 'g':
      {
        if(et_par!=-1)
        {
            break;
        }
        if(et>1) et_par = 2;
        if(to>1) et_par = 4;
        if(tre>1) et_par = 6;
        if(fire>1) et_par = 8;
        if(fem>1) et_par = 10;
        if(seks>1) et_par = 12;

        cout << et_par;
      break;
      }
        case 'h':
      {
        if(to_par!=-1)
        {
            break;
        }
          bool test= false;
            if(et>1)
            {
                test=true;
                to_par =2;
        }
        if(to>1)
                {
                    if(test)
                {
                    to_par = to_par+4;
                  cout << to_par;
                      break;
                }
              to_par=4;
                    test= true;
            }
        if(tre>1)
                {
                    if(test)
                {
                    to_par = to_par+6;
                  cout << to_par;
                      break;
                }
              to_par=6;
                    test= true;
            }
        if(fire>1)
                {
                    if(test)
                {
                    to_par = to_par+8;
                  cout << to_par;
                      break;
                }
              to_par=8;
                    test= true;
            }
        if(fem>1)
                {
                    if(test)
                {
                    to_par = to_par+10;
                  cout << to_par;
                      break;
                }
              to_par=10;
                    test= true;
            }
        if(seks>1)
                {
                    if(test)
                {
                    to_par = to_par+12;
                  cout << to_par;
                      break;
                }

            }
            to_par=0;
            cout << to_par;
            break;
      }


      case 'i':
          {
            if(tre_ens!=-1)
        {
            break;
        }
              if(et>2)
            {
                tre_ens =3;
            cout << tre_ens;
            break;
        }


        if(to>2)
            {
                tre_ens =6;
            cout << tre_ens;
            break;
        }

        if(tre>2)
            {
                tre_ens =9;
            cout << tre_ens;
            break;
        }


        if(fire>2)
            {
                tre_ens =12;
            cout << tre_ens;
            break;
        }
          if(fem>2)
            {
                tre_ens =15;
            cout << tre_ens;
            break;
        }


        if(seks>2)
            {
                tre_ens =18;
            cout << tre_ens;
            break;
        }

          tre_ens=0;
        cout << tre_ens;
        break;
        }

      case 'j':
          {
        if(fire_ens!=-1)
        {
            break;
        }
        if(et>3)
            {
                fire_ens =4;
            cout << fire_ens;
            break;
        }


        if(to>3)
            {
                fire_ens =8;
            cout << fire_ens;
            break;
        }

        if(tre>3)
            {
                fire_ens =12;
            cout << fire_ens;
            break;
        }


        if(fire>3)
            {
                fire_ens =16;
            cout << fire_ens;
            break;
        }


        if(fem>3)
            {
                fire_ens =20;
            cout << fire_ens;
            break;
        }


        if(seks>3)
            {
                fire_ens =24;
            cout << fire_ens;
            break;
        }

          fire_ens=0;
        cout << fire_ens;
        break;
        }

      case 'k':
          {
            if(den_lille!=-1)
        {
            break;
        }
        bool test= false;
            if((et==1)&&(to==1)&&(tre==1)&&(fire==1)&&(fem==1))
            {
                test=true;
                den_lille =15;
            cout << den_lille;
            break;
        }

          den_lille=0;
        cout << den_lille;
        break;
        }

      case 'l':
          {
            if(den_store!=-1)
        {
            break;
        }
        bool test= false;
            if((to==1)&&(tre==1)&&(fire==1)&&(fem==1)&&(seks==1))
            {
                test=true;
                den_store =20;
            cout << den_store;
            break;
        }

          den_store=0;
        cout << den_store;
        break;
        }

      case 'm':
          {
            if(fuldt_hus!=-1)
        {
            break;
        }
        bool test= false;
            if((et==2)&&(to==3))
            {
                fuldt_hus =8;
            cout << fuldt_hus;
            break;
        }

        if((et==2)&&(tre==3))
            {
              fuldt_hus=11;
            cout << fuldt_hus;
            break;
            }
        if((et==2)&&(fire==3))
            {

              fuldt_hus=14;
            cout << fuldt_hus;
            break;
            }
        if((et==2)&&(fem==3))
            {
              fuldt_hus=17;
            cout << fuldt_hus;
            break;
            }
        if((et==2)&&(seks==3))
        {
              fuldt_hus=21;
            cout << fuldt_hus;
            break;
            }
        if((to==2)&&(et==3))
            {
              fuldt_hus=7;
            cout << fuldt_hus;
            break;
            }
        if((tre==2)&&(et==3))
            {
              fuldt_hus=9;
            cout << fuldt_hus;
            break;
            }
        if((fire==2)&&(et==3))
            {
              fuldt_hus=11;
            cout << fuldt_hus;
                break;
            }
        if((fem==2)&&(et==3))
            {
              fuldt_hus=13;
            cout << fuldt_hus;
                break;
            }
        if((seks==2)&&(et==3))
            {
              fuldt_hus=15;
            cout << fuldt_hus;
                break;
            }
        if((to==2)&&(tre==3))
            {
              fuldt_hus=13;
            cout << fuldt_hus;
                break;
            }
        if((to==2)&&(fire==3))
            {
              fuldt_hus=16;
            cout << fuldt_hus;
                break;
            }
        if((to==2)&&(fem==3))
            {
              fuldt_hus=19;
            cout << fuldt_hus;
                break;
            }
        if((to==2)&&(seks==3))
            {
              fuldt_hus=22;
            cout << fuldt_hus;
                break;
            }
        if((tre==2)&&(to==3))
            {
              fuldt_hus=12;
            cout << fuldt_hus;
                break;
            }
        if((fire==2)&&(to==3))
            {
              fuldt_hus=14;
            cout << fuldt_hus;
                break;
            }
        if((fem==2)&&(to==3))
            {
              fuldt_hus=16;
            cout << fuldt_hus;
                break;
            }
        if((seks==2)&&(to==3))
            {
              fuldt_hus=18;
            cout << fuldt_hus;
                break;
            }
        if((tre==2)&&(fire==3))
            {
              fuldt_hus=18;
            cout << fuldt_hus;
                break;
            }
        if((tre==2)&&(fem==3))
            {
              fuldt_hus=21;
            cout << fuldt_hus;
                break;
            }
        if((tre==2)&&(seks==3))
            {
              fuldt_hus=24;
            cout << fuldt_hus;
                break;
            }
        if((fire==2)&&(tre==3))
            {
              fuldt_hus=17;
            cout << fuldt_hus;
                break;
            }
        if((fem==2)&&(tre==3))
            {
              fuldt_hus=19;
            cout << fuldt_hus;
                break;
            }
        if((fire==2)&&(fem==3))
            {
              fuldt_hus=23;
            cout << fuldt_hus;
                break;
            }
        if((fire==2)&&(seks==3))
            {
              fuldt_hus=26;
            cout << fuldt_hus;
                break;
            }
        if((fem==2)&&(fire==3))
            {
              fuldt_hus=22;
            cout << fuldt_hus;
                break;
            }
        if((seks==2)&&(fire==3))
            {
              fuldt_hus=24;
            cout << fuldt_hus;
                break;
            }
        if((fem==2)&&(seks==3))
            {
              fuldt_hus=28;
            cout << fuldt_hus;
                break;
            }
        if((seks==2)&&(fem==3))
            {
              fuldt_hus=27;
            cout << fuldt_hus;
                break;
        }

        fuldt_hus=0;
        cout << fuldt_hus;
        break;
        }

      case 'n':
          {
        if(yatzy!=-1)
        {
            break;
        }
        bool test= false;
            if(et==5)
            {
                test=true;
                yatzy =55;
            cout << yatzy;
            break;
        }

        if(to==5)
            {
                test=true;
                yatzy =60;
            cout << yatzy;
            break;
        }

        if(tre==5)
            {
                test=true;
                yatzy =65;
            cout << yatzy;
            break;
        }

        if(fire==5)
            {
                test=true;
                yatzy =70;
            cout << yatzy;
            break;
        }


        if(fem==5)
            {
                test=true;
                yatzy =75;
            cout << yatzy;
            break;
        }


        if(seks==5)
            {
                test=true;
                yatzy =80;
            cout << yatzy;
            break;
        }

          yatzy=0;
        cout << yatzy;
        break;
        }

      case 'o':
      {
        if(chancen!=-1)
        {
            break;
        }
        chancen=0;
        for(int n=1; n<TERNINGER+1;n++)
        {
        chancen=chancen+(terningervardi[n]);
        }
        cout << chancen;
        break;
      }
      case 'p':
      {
        total;
        int tempchancen;
        int tempyatzy;
        int tempfuldt_hus;
        int tempden_store;
        int tempden_lille;
        int tempfire_ens;
        int temptre_ens;
        int tempto_par;
        int tempet_par;
        int tempsekser;
        int tempfemer;
        int tempfirer;
        int temptrer;
        int temptoer;
        int tempeter;

        if(eter==-1)
          {
          tempeter=0;
          }
        else
          {
            tempeter=eter;
          }
        if(toer==-1)
          {
          temptoer=0;
          }
        else
          {
            temptoer=toer;
          }
        if(trer==-1)
          {
          temptrer=0;
          }
        else
          {
            temptrer=trer;
          }
        if(firer==-1)
          {
          tempfirer=0;
          }
        else
          {
            tempfirer=firer;
          }
        if(femer==-1)
          {
          tempfemer=0;
          }
        else
          {
            tempfemer=femer;
          }
        if(sekser==-1)
          {
          tempsekser=0;
          }
          else
          {
            tempsekser=sekser;
          }
        if(et_par==-1)
          {
          tempet_par=0;
          }
            else
          {
            tempet_par=et_par;
          }
        if(to_par==-1)
          {
          tempto_par=0;
          }
            else
          {
            tempto_par=to_par;
          }
        if(tre_ens==-1)
          {
          temptre_ens=0;
          }
        else
          {
            temptre_ens=tre_ens;
          }
        if(den_lille==-1)
          {
          tempden_lille=0;
          }
        else
          {
            tempden_lille=den_lille;
          }
        if(den_store==-1)
          {
          tempden_store=0;
          }
        else
          {
            tempden_store=den_store;
          }
        if(fuldt_hus==-1)
          {
          tempfuldt_hus=0;
          }
        else
          {
            tempeter=eter;
          }
        if(yatzy==-1)
          {
          tempyatzy=0;
          }
        else
          {
            tempyatzy=yatzy;
          }
        if(chancen==-1)
          {
          tempchancen=0;
          }
            else
          {
            tempchancen=chancen;
          }
      int bt;
      bonus=0;
      bt= (tempeter+temptoer+temptrer+tempfirer+tempfemer+tempsekser);
      if (bt>62)
          {
        bonus=50;
        }
        else
        {
        bonus=0;
        }
      total=(tempeter+temptoer+temptrer+tempfirer+tempfemer+tempsekser+tempet_par+
      tempto_par+temptre_ens+tempfire_ens+tempden_lille+tempden_store+
      tempfuldt_hus+tempyatzy+tempchancen+bonus);
        cout << total;
        break;
      }
  }
  return 0;
}

//////////////////////////////////////////////////////////////////////////////
//
//  Funktion         : blokken::FraSpil
//
//  Input            : bool b1=true
//  Output            :
//  Globale par    : bruger1.single,bruger1.multip1,bruger1.multip2
//
//  Beskrivelse    : henter blokkens data over i bruger1 til gemning
//
///////////////////////////////////////////////////////////////////////////////

void blokken::FraSpil(bool b1=true)
{
if (b1)
{
    bruger1.single[0]=blok1.eter;
    bruger1.single[1]=blok1.toer;
    bruger1.single[2]=blok1.trer;
    bruger1.single[3]=blok1.firer;
    bruger1.single[4]=blok1.femer;
    bruger1.single[5]=blok1.sekser;
    bruger1.single[6]=blok1.et_par;
    bruger1.single[7]=blok1.to_par;
    bruger1.single[8]=blok1.tre_ens;
    bruger1.single[9]=blok1.fire_ens;
    bruger1.single[10]=blok1.den_lille;
    bruger1.single[11]=blok1.den_store;
    bruger1.single[12]=blok1.fuldt_hus;
    bruger1.single[13]=blok1.yatzy;
    bruger1.single[14]=blok1.chancen;
}
else
{
    bruger1.multip1[0]=blok1.eter;
    bruger1.multip1[1]=blok1.toer;
    bruger1.multip1[2]=blok1.trer;
    bruger1.multip1[3]=blok1.firer;
    bruger1.multip1[4]=blok1.femer;
    bruger1.multip1[5]=blok1.sekser;
    bruger1.multip1[6]=blok1.et_par;
    bruger1.multip1[7]=blok1.to_par;
    bruger1.multip1[8]=blok1.tre_ens;
    bruger1.multip1[9]=blok1.fire_ens;
    bruger1.multip1[10]=blok1.den_lille;
    bruger1.multip1[11]=blok1.den_store;
    bruger1.multip1[12]=blok1.fuldt_hus;
    bruger1.multip1[13]=blok1.yatzy;
    bruger1.multip1[14]=blok1.chancen;
    bruger1.multip2[0]=blok2.eter;
    bruger1.multip2[1]=blok2.toer;
    bruger1.multip2[2]=blok2.trer;
    bruger1.multip2[3]=blok2.firer;
    bruger1.multip2[4]=blok2.femer;
    bruger1.multip2[5]=blok2.sekser;
    bruger1.multip2[6]=blok2.et_par;
    bruger1.multip2[7]=blok2.to_par;
    bruger1.multip2[8]=blok2.tre_ens;
    bruger1.multip2[9]=blok2.fire_ens;
    bruger1.multip2[10]=blok2.den_lille;
    bruger1.multip2[11]=blok2.den_store;
    bruger1.multip2[12]=blok2.fuldt_hus;
    bruger1.multip2[13]=blok2.yatzy;
    bruger1.multip2[14]=blok2.chancen;
}
}
//////////////////////////////////////////////////////////////////////////////
//
//  Funktion         : blokken::TilSpil
//
//  Input            : bool b1=true
//  Output            :
//  Globale par    : bruger1.single,bruger1.multip1,bruger1.multip2
//
//  Beskrivelse    : henter brugerens data over blokken til at spille.
//
///////////////////////////////////////////////////////////////////////////////


void blokken::TilSpil(bool b1=true)
{
if (b1)
{
    blok1.eter=bruger1.single[0];
    blok1.toer=bruger1.single[1];
    blok1.trer=bruger1.single[2];
    blok1.firer=bruger1.single[3];
    blok1.femer=bruger1.single[4];
    blok1.sekser=bruger1.single[5];
    blok1.et_par=bruger1.single[6];
    blok1.to_par=bruger1.single[7];
    blok1.tre_ens=bruger1.single[8];
    blok1.fire_ens=bruger1.single[9];
    blok1.den_lille=bruger1.single[10];
    blok1.den_store=bruger1.single[11];
    blok1.fuldt_hus=bruger1.single[12];
    blok1.yatzy=bruger1.single[13];
    blok1.chancen=bruger1.single[14];
}
else
{
    blok1.eter=bruger1.multip1[0];
    blok1.toer=bruger1.multip1[1];
    blok1.trer=bruger1.multip1[2];
    blok1.firer=bruger1.multip1[3];
    blok1.femer=bruger1.multip1[4];
    blok1.sekser=bruger1.multip1[5];
    blok1.et_par=bruger1.multip1[6];
    blok1.to_par=bruger1.multip1[7];
    blok1.tre_ens=bruger1.multip1[8];
    blok1.fire_ens=bruger1.multip1[9];
    blok1.den_lille=bruger1.multip1[10];
    blok1.den_store=bruger1.multip1[11];
    blok1.fuldt_hus=bruger1.multip1[12];
    blok1.yatzy=bruger1.multip1[13];
    blok1.chancen=bruger1.multip1[14];
    blok2.eter=bruger1.multip2[0];
    blok2.toer=bruger1.multip2[1];
    blok2.trer=bruger1.multip2[2];
    blok2.firer=bruger1.multip2[3];
    blok2.femer=bruger1.multip2[4];
    blok2.sekser=bruger1.multip2[5];
    blok2.et_par=bruger1.multip2[6];
    blok2.to_par=bruger1.multip2[7];
    blok2.tre_ens=bruger1.multip2[8];
    blok2.fire_ens=bruger1.multip2[9];
    blok2.den_lille=bruger1.multip2[10];
    blok2.den_store=bruger1.multip2[11];
    blok2.fuldt_hus=bruger1.multip2[12];
    blok2.yatzy=bruger1.multip2[13];
    blok2.chancen=bruger1.multip2[14];
}

}

//////////////////////////////////////////////////////////////////////////////
//
//  Funktion         : blokken::resetblok
//
//  Input            :
//  Output            :
//  Globale par    :
//
//  Beskrivelse    : nul terminering af blokkens data
///////////////////////////////////////////////////////////////////////////////

void blokken::resetblok()
{
  eter=-1;
  toer=-1;
  trer=-1;
  firer=-1;
  femer=-1;
  sekser=-1;
  et_par=-1;
  to_par=-1;
  tre_ens=-1;
  fire_ens=-1;
  den_lille=-1;
  den_store=-1;
  fuldt_hus=-1;
  yatzy=-1;
  chancen=-1;
}
//////////////////////////////////////////////////////////////////////////////
//
//  Funktion         : bgf::logon
//
//  Input            :
//  Output            : bool
//  Globale par    :
//
//  Beskrivelse    : Bruger logon
//
///////////////////////////////////////////////////////////////////////////////
bool bgf::logon(bool b1=true)
{
  char valg2;
    clrscr();
  cout << "-----------------------------"<< endl << endl;
    cout << "Velkommen til DropOut Yatzy" << endl << endl;
  cout << "-----------------------------"<< endl << endl;
      cout << "1:Logon"<< endl << endl;
  cout << "2:Quit"<< endl << endl;
  cout << "-----------------------------"<< endl << endl;
  cout << "Indtast dit valg:    ";

      do
  {
      valg2=getch();
  }
      while((valg2 !='1')&&(valg2!='2'));
      switch(valg2)
      {
          case '1':
        {
                  cout << endl << endl << endl << "Indtast Bruger Navn: ";
                if(b1) cin.getline (bruger1.navn, 256);
            else cin.getline (bruger2.navn, 256);
            return true;
        }

            case '2':          // da det er en char værdi, bruges ''.
              {
            return false;
      }
  }
return 0;
}


///////////////////////////////////////////////////////////////////////////////
//
//  Funktion         : bgf::viewhighscore();
//
//  Input            :
//  Output            :
//  Globale par    : bruger1.highscore
//
//  Beskrivelse    : Viser highscoren
//
///////////////////////////////////////////////////////////////////////////////

void bgf::viewhighscore(bool b1=true)
{

        clrscr();        // Ryder skærmen og udskriver menuen på en ny.

      if(b1)
      {
          if(!bruger1.hentdata(bruger1.navn))
              {
                  bruger1.gembruger(bruger1.navn);
              }
              cout << "-----------------------------"<< endl << endl;
                  cout << "Din top 10 score: " << endl << endl;
                  cout << "-----------------------------"<< endl << endl;
                  cout << "1: " << bruger1.highscore [9]<< endl;
                  cout << "2: " << bruger1.highscore [8]<< endl;
                  cout << "3: " << bruger1.highscore [7]<< endl;
              cout << "4: " << bruger1.highscore [6]<< endl;
                cout << "5: " << bruger1.highscore [5]<< endl;
                cout << "6: " << bruger1.highscore [4]<< endl;
                cout << "7: " << bruger1.highscore [3]<< endl;
              cout << "8: " << bruger1.highscore [2]<< endl;
                cout << "9: " << bruger1.highscore [1]<< endl;
                cout << "10: "<< bruger1.highscore [0]<< endl;
                cout << "-----------------------------"<< endl << endl;
                cout << "Tryk paa en tast for at fortsaette ";
      }

      else
      {
      if(!bruger2.hentdata(bruger2.navn))
              {
                bruger2.gembruger(bruger2.navn);
              }
        cout << "-----------------------------"<< endl << endl;
          cout << "Din top 10 score: " << endl << endl;
          cout << "-----------------------------"<< endl << endl;
          cout << "1: " << bruger2.highscore [9]<< endl;
          cout << "2: " << bruger2.highscore [8]<< endl;
          cout << "3: " << bruger2.highscore [7]<< endl;
      cout << "4: " << bruger2.highscore [6]<< endl;
        cout << "5: " << bruger2.highscore [5]<< endl;
        cout << "6: " << bruger2.highscore [4]<< endl;
        cout << "7: " << bruger2.highscore [3]<< endl;
      cout << "8: " << bruger2.highscore [2]<< endl;
        cout << "9: " << bruger2.highscore [1]<< endl;
        cout << "10: "<< bruger2.highscore [0]<< endl;
        cout << "-----------------------------"<< endl << endl;
        cout << "Tryk paa en tast for at fortsaette ";
      }
        getch();
}


///////////////////////////////////////////////////////////////////////////////
//
//  Funktion         : bgf::spiltype_menu
//
//  Input            : char
//  Output            : bool
//  Globale par    :
//
//  Beskrivelse    : Gør det muligt at vælge de forskelige typer
//                          spil som er krævet
//
///////////////////////////////////////////////////////////////////////////////

bool bgf::spiltype_menu()
{
  char spiltypenr;

    clrscr();        // Ryder skærmen og udskriver menuen på en ny.

  cout << "-----------------------------------------" << endl << endl;
  cout << "Vaelg spiltype: " << endl << endl;
  cout << "-----------------------------------------" << endl << endl;
  cout << "0: Single player" << endl;
  cout << "1: Single player m. timer" << endl;
  cout << "2: Spiller mod Virtuel player" << endl;
  cout << "3: Spiller mod Virtuel player m. timer" << endl;
  cout << "4: 2 Player" << endl;
  cout << "5: 2 Player m. timer" << endl;
  cout << "6: Hent single player spil" << endl;
  cout << "7: Hent Spiller mod Virtuel player" << endl << endl << endl;
  cout << "8: Quit" << endl << endl;
  cout << "-----------------------------------------" << endl << endl;
  cout << "Indtast valg: ";

  do
    {
          spiltypenr=getch();
  }

  while((spiltypenr !='0')&&(spiltypenr !='1')&&(spiltypenr !='2')
            &&(spiltypenr !='3')&&(spiltypenr !='4')&&(spiltypenr !='5')
        &&(spiltypenr !='6')&&(spiltypenr !='7')&&(spiltypenr !='8'));

  switch(spiltypenr)
  {
          case '0':
          {
            blok1.resetblok();
            SingleSpil();
            blok1.FraSpil();
            high1.sorter(bruger1.highscore, &blok1.total);
            high1.OpdaterTop10(bruger1.navn,&blok1.total);
            bruger1.gembruger(bruger1.navn);
          }
          break;

            case '1':



          break;

        case '2':



          break;

            case '3':



          break;

            case '4':



          break;

            case '5':



          break;

            case '6':
            bruger1.hentdata(bruger1.navn);
            blok1.TilSpil();
            SingleSpil();
            high1.OpdaterTop10(bruger1.navn,&blok1.total);
            blok1.FraSpil();
            bruger1.gembruger(bruger1.navn);


          break;

            case '7':



          break;

        case '8':
                  return false;



  }
  return true;
}

///////////////////////////////////////////////////////////////////////////////
//
//  Funktion         : bgf::viewTop10point
//
//  Input            :
//  Output            :
//  Globale par    :
//
//  Beskrivelse    : Viser Top 10 efter point
//
///////////////////////////////////////////////////////////////////////////////

void bgf::viewTop10point()
{
  high1.HighscorePoint();
  clrscr();
  gotoxy(30,1);
  cout << "-----------------------------";
  gotoxy(30,2);
  cout << "Point Top 10: ";
  gotoxy(30,3);
  cout << "-----------------------------";
  for (int a=9; a>=0;a--)
  {
      gotoxy(30,(((10-a)*2)+3));
      cout << (10-a) << ") " << high1.top10[a];
  }
}

///////////////////////////////////////////////////////////////////////////////
//
//  Funktion         :    bgf1::viewTop10navn
//
//  Input            :
//  Output            :
//  Globale par    :
//
//  Beskrivelse    :    Viser Top 10 efter navn
//
///////////////////////////////////////////////////////////////////////////////

void bgf::viewTop10navn()
{
    high1.SorterTop10Navn();
  clrscr();
  gotoxy(30,1);
  cout << "-----------------------------";
  gotoxy(30,2);
  cout << "Navn Top 10: ";
  gotoxy(30,3);
  cout << "-----------------------------";
  for (int a=9; a>=0;a--)
  {
      gotoxy(30,((10-a)*2)+3);
      cout << high1.ChartalAr[a] << high1.charnavn[a];
  }
}

///////////////////////////////////////////////////////////////////////////////
//
//  Funktion         :    bgf::Afslutningsmenu
//
//  Input            :
//  Output            :    bool
//  Globale par    :
//
//  Beskrivelse    : Gør det muligt at vælge sortere highscoren på forskellige
//                  måder efter kravene
//
///////////////////////////////////////////////////////////////////////////////

int bgf::afslutningsmenu()
{
char slutvalg;

cout << "1: Slet Highscore og brugere" << endl;
cout << "2: Vis Highscore, point" << endl;
cout << "3: Vis Highscore, navn"<< endl;
cout << "4: Nyt spil" << endl;
cout << "5: afslut spil" << endl << endl;
cout << "Indtast valg: ";

do
    {
        slutvalg=getch();

    }
    while((slutvalg !='1')&&(slutvalg !='2')&&(slutvalg !='3')
          &&(slutvalg !='4')&&(slutvalg !='5'));

    switch(slutvalg)
    {
          case '1':


      case '2':
          return 2;


      case '3':
      return 3;


      case '4':
        return 1;


      case '5':
        return 0;

    }
    return 0;
}

///////////////////////////////////////////////////////////////////////////////
//
//  Funktion         : bgf::SingleSpil
//
//  Input            :
//  Output            :
//  Globale par    :
//
//  Beskrivelse    :  styring af single player spil
//
///////////////////////////////////////////////////////////////////////////////

void bgf::SingleSpil()
{
  clrscr();
      gotoxy(30,5);
  cout << "a: enere";
      gotoxy(30,6);
  cout << "b: toere";
      gotoxy(30,7);
  cout << "c: trere";
      gotoxy(30,8);
  cout << "d: firere";
      gotoxy(30,9);
  cout << "e: femmere";
      gotoxy(30,10);
  cout << "f: seksere";
      gotoxy(30,11);
  cout << "bonus";
      gotoxy(30,12);
  cout << "g: et par";
      gotoxy(30,13);
  cout << "h: to par";
      gotoxy(30,14);
  cout << "i: tre ens";
      gotoxy(30,15);
  cout << "j: fire ens";
      gotoxy(30,16);
  cout << "k: den lille";
      gotoxy(30,17);
  cout << "l: den store";
      gotoxy(30,18);
  cout << "m: fuldt hus";
      gotoxy(30,19);
  cout << "n: chance";
      gotoxy(30,20);
  cout << "o: Yatzy";
      gotoxy(30,21);
  cout << "total";
      gotoxy(1,3);
  cout << "s: slaa";
      gotoxy(1,4);
  cout << "v: valg";
      gotoxy(1,5);
  cout << "Q: afslut spil";
      gotoxy(1,10);
  cout << "Timer: off";
      gotoxy(1,15);
  cout << "tur nr.";
      gotoxy(1,16);
  cout << "terning nr. 1 2 3 4 5";
      gotoxy(1,17);
  cout << "værdi: ";
      gotoxy(1,23);
  cout << bruger1.navn;
      gotoxy(45,3);
  cout << bruger1.navn;
      gotoxy(42,5);
  cout << blok1.eter;
      gotoxy(42,6);
  cout << blok1.toer;
      gotoxy(42,7);
  cout << blok1.trer;
      gotoxy(42,8);
  cout << blok1.firer;
      gotoxy(42,9);
  cout << blok1.femer;
      gotoxy(42,10);
  cout << blok1.sekser;
      gotoxy(42,11);
  cout << blok1.bonus;
      gotoxy(42,12);
  cout << blok1.et_par;
      gotoxy(42,13);
  cout << blok1.to_par;
      gotoxy(42,14);
  cout << blok1.tre_ens;
      gotoxy(42,15);
  cout << blok1.fire_ens;
      gotoxy(42,16);
  cout << blok1.den_lille;
      gotoxy(42,17);
  cout << blok1.den_store;
      gotoxy(42,18);
  cout << blok1.fuldt_hus;
      gotoxy(42,19);
  cout << blok1.chancen;
      gotoxy(42,20);
  cout << blok1.yatzy;
      gotoxy(42,21);
  cout << blok1.total;

  char tast;

  bool t1;
  bool t2;
  bool t3;
  bool t4;
  bool t5;

  for(int slag=0;slag<3; slag++)
  {
  t1=true;
  t2=true;
  t3=true;
  t4=true;
  t5=true;
  baeger1.rysteterning(t1,t2,t3,t4,t5);


    for(int n=1;n<3;n++)
  {
      gotoxy(8,15);
      cout << n;

      do
      {
        tast= getch();
        if (tast == '1')
            {
            if(t1)
              {
                    t1=false;
                    gotoxy(12,18);
                    cout << "*";
              }
            else
                {
                    t1=true;
                    gotoxy(12,18);
                    cout << " ";
                }
            tast='\0';
            }
        if (tast == '2')
            {
                if(t2)
            {
                t2=false;
                gotoxy(14,18);
                  cout << "*";
            }
        else
        {
            t2=true;
            gotoxy(14,18);
            cout << " ";
        }
    }
    if (tast == '3')
    {
            if(t3)
        {
            t3=false;
            gotoxy(16,18);
            cout << "*";
        }
        else
        {
            t3=true;
            gotoxy(16,18);
            cout << " ";
        }
    }
    if (tast == '4')
    {
            if(t4)
        {
            t4=false;
            gotoxy(18,18);
            cout << "*";
        }
        else
        {
            t4=true;
            gotoxy(18,18);
            cout << " ";
        }
    }
    if (tast == '5')
    {
            if(t5)
        {
            t5=false;
            gotoxy(20,18);
            cout << "*";
        }
        else
        {
            t5=true;
            gotoxy(20,18);
            cout << " ";
        }
    }

  }
  while(tast =='\0');

  baeger1.rysteterning(t1,t2,t3,t4,t5);
      gotoxy(12,17);
  cout << terning1.terningervardier[1];
      gotoxy(14,17);
  cout << terning1.terningervardier[2];
      gotoxy(16,17);
  cout << terning1.terningervardier[3];
      gotoxy(18,17);
  cout << terning1.terningervardier[4];
      gotoxy(20,17);
  cout << terning1.terningervardier[5];
  }
  char v;
  do
  {
      v=getch();
  }
  while((v<'a')&&(v>'0')&&(v!='q'));

  if(v=='q')
  {
      gotoxy(1,25);
      cout << "Vil du gemme? (j/n)";
      int w;
      do
      {
          w=getch();
      }
      while((w!='j')||(w!='n'));
      if(w=='j')
      {
        blok1.FraSpil();
        bruger1.gembruger(bruger1.navn);
        blok1.total=0;
      }
  return;
  }

  blok1.blok(v);
  blok1.blok('p');

  if (v=='a')
  {
      gotoxy(42,5);
      cout << blok1.eter;
  }
  if (v=='b')
  {
      gotoxy(42,6);
      cout << blok1.toer;
  }
  if (v=='c')
  {
          gotoxy(42,7);
      cout << blok1.trer;
  }
  if (v=='d')
  {
      gotoxy(42,8);
      cout << blok1.firer;
  }
  if (v=='e')
  {
      gotoxy(42,9);
      cout << blok1.femer;
  }
  if (v=='f')
  {
      gotoxy(42,10);
      cout << blok1.sekser;
  }
      gotoxy(42,11);
      cout << blok1.bonus;
  if (v=='g')
  {
      gotoxy(42,12);
      cout << blok1.et_par;
  }
  if (v=='h')
  {
      gotoxy(42,13);
      cout << blok1.to_par;
  }
  if (v=='i')
  {
      gotoxy(42,14);
      cout << blok1.tre_ens;
  }
  if (v=='j')
  {
      gotoxy(42,15);
      cout << blok1.fire_ens;
  }
  if (v=='k')
  {
      gotoxy(42,16);
      cout << blok1.den_lille;
  }
  if (v=='l')
  {
      gotoxy(42,17);
      cout << blok1.den_store;
  }
  if (v=='m')
  {
      gotoxy(42,18);
      cout << blok1.fuldt_hus;
  }
  if (v=='n')
  {
      gotoxy(42,19);
      cout << blok1.chancen;
  }
  if (v=='o')
  {
          gotoxy(42,20);
      cout << blok1.yatzy;
  }
      gotoxy(42,21);
      cout << blok1.total;
  }
}


///////////////////////////////////////////////////////////////////////////////
//
//  Funktion         : bfg::viewTop10point
//
//  Input            :
//  Output            :
//  Globale par    :
//
//  Beskrivelse    : Viser Top 10 efter point
//
///////////////////////////////////////////////////////////////////////////////

void bgf::MultiSpil()
{

}





///////////////////////////////////////////////////////////////////////////////
//
//  Funktion         :    bgf::Handler
//
//  Input            :
//  Output            :
//  Globale par    :
//
//  Beskrivelse    : Styring af selve spillet
//
///////////////////////////////////////////////////////////////////////////////

void bgf::handler()
{
int navn;

  for(;;)
  {
      navn=2;
    if(!bgf1.logon())
  {
      return;
  }

  bgf1.viewhighscore();

  if(!bgf1.spiltype_menu())
  {
        return;
  }

  do
  {
      if(navn==2)
      {
          viewTop10point();
      }

      if(navn==3)
      {
          viewTop10navn();
      }

      if(navn==0)
      {
          return;
      }

      navn=afslutningsmenu();
  }
  while((navn!=1));
  }

}
////////////////////////////////////////////////////////////////////////////////
//  Funktion         :    void main()
//
//  Input            :
//  Output            :
//  Globale par    :
//
//  Beskrivelse    : Aktiverer hendleren
//
///////////////////////////////////////////////////////////////////////////////

void main()
{
bgf1.handler();
}

1)

void main() -> int main()

2)

#include <iostream.h>
#include <fstream.h>

->

#include <iostream>
#include <fstream>
using namespace std;

3)

= { NULL };

->

= { 0 };

4)

blokken::blok(char pointvalg='0')

->

int blokken::blok(char pointvalg='0')

vil nok fjerne en hel del warnings.

Til Arne V: Jeg siger tak for hjælpen! Men der forsvandt ingen fejl! Jeg kan også lige oplyse at jeg bruger borland 5.2 compileren, hvis det gør nogen forandring!

sorry, borland 5.02

Hvilke fejl får I ?

Hvis man i void bgf::SingleSpil() vælger 'q' kommer man ind i følgende:
cout << "Vil du gemme? (j/n)";
int w;
do
{
  w = getch();
}
while((w != 'j') || (w != 'n'));

Det er der ikke nogen vej ud af da w altid er forskellig fra 'j' eller 'n'

I samme funktion har I:
char v;
do
{
  v=getch();
}
while(( v < 'a') && (v > '0') && (v != 'q'));
Hvilket måske ikke er nogen god ide da man ikke ved om 'a' er større eller mindre end '0'

I samme funktion har I:
tast = getch();
if (tast == '1')
{
  ...
  tast='\0';
}
if (tast == '2')
{
...
}
Her kunne man få den ide at "tast = '\0';" mangler for "if(tast == '2')" (og == 3, 4, 5) men det er ikke helt klart hvad det er i ønsker at opnå.

'a' skal nok være større end '0' (programmet er absolut ikke portabelt).

men hvad de 48 tegn '1'..'`' har tilfælles ved jeg ikke.

Hvis Bertels rettelser ikke er nok specificer venligst hvad der ikke fungerer, gennem et konkret exemple af brug.

okay... jeg forstår ikke rigtig alle Bertels rettelser, men for at forklare hvordan det skal virke: når man starter spillet, får man et skærmbillede af logonfasen, og denne del af programmet virker fint, så kommer man videre til at få fremvist sin top 10, og det virker også fint nok, så kommer man til at man kan vælge hvilken slags spil man vil spille (Det er kun de to typer singleplayer spil vi har lavet progammet med), og denne del virker også fint nok! Så er det det går galt! Hvis i har prøvet at kompilere programmet, kan i også se det! Det første man ser, fungerer fint nok, bort set fra at det et der nede i totalen er et ettal (Det kan vi selv finde ud af at rette). Men det er nu meningen at man skulle kunne spille yatzy, sådan som der er lavet omkring en million yatzy-singelplayerspil før. Det var meningen at terningerne skulle slå der hvor jeg har indsat x'ere her nedenunder:
"Terning nr. 1 2 3 4 5"
"vµrdi:"    x x x x x

Men de slår på det forkerte x,y kordinat, i forhold til hvor vi har sat den, og den sletter heller ikke sig selv (clrscr) for hver gang den har slået, som vi også gerne vil have den til. Derefter kommer problemet med at indsætte point i "blokken", når man trykker en af de taster som vi har sat til de forskellige funktioner ovre i blokken, skriver den bare nogle tal ud (som om at den slår med terningen.) og det kan man så få lov til et hvis antal gange (det var ikke meningen!) Og så bliver man smidt ud til final menuen lidt for tidligt!

Jeg håber at dette kan hjælpe jer med at se lidt mere, hvad vi gerne ville have haft at vores lille program skulle have kunnet!

Hvis du/I har nogle specifikke spørgsmål/problemer om/med C/C++ vil jeg gerne hjælpe jer, men jeg gider ikke bruge tid på at finde simple logiske fejl i et 2000 liniers C++ program.

Jeg går ud fra at alle problemerne er i singleplayer.

jeres clrscr() stå uden for den inderste løkke så den sletter ikke hver gang.

De koordinater ser jo gode ud.
Men hvis i erstatter alle de 17 taller der angiver y-koordinat for terning kast med en constant fx.
#define DIELINE (17)
alle steder hvor i henviser til den linie kan i måske nemmere overskue hvor jeres koordinater går forkert, det samme gælder egentlig også alle andre magiske tal/koordinater.

    gotoxy(1, DIELINE-1);
  cout << "terning nr. 1 2 3 4 5";


  baeger1.rysteterning(t1,t2,t3,t4,t5);
      gotoxy(12, DIELINE);
  cout << terning1.terningervardier[1];
      gotoxy(14,DIELINE);
  cout << terning1.terningervardier[2];
      gotoxy(16,DIELINE);
  cout << terning1.terningervardier[3];
      gotoxy(18,DIELINE);
  cout << terning1.terningervardier[4];
      gotoxy(20,DIELINE);
  cout << terning1.terningervardier[5];

Jeg siger tak for alt den hjælp vi har fået her

Vi siger tak for alt den hjælp vi har fået herinde(segmose og arnold)! Der er desværre ikke nogle af jer der har kunne forklare os hvordan vi evt. kommer videre fra det punkt, hvor vi egentligt begyndte! Vi har imidlertid fået hjælp andetsteds fra, så derfor vælger jeg ikke at give alle mine 150 point væk!

hep