Programmera spel i C++ för nybörjare/Hänga gubbe 1

Från Wikibooks
Hoppa till navigering Hoppa till sök


Hangman

Grafiken finns här (självuppackande arkiv):

http://dl.dropbox.com/u/8595437/grafik_sfml_hangman.exe

Grafiken som krävs är:

  • 30 st 60x60 pixels med alfabetets alla bokstäver samt en "-" bokstav för sammansatta ord.
  • 1 st 800x600 bakgrundsbild
  • 13 st 400x600 bilder som föreställer hängningen där 1 är en kulle och 13 en färdig hängd gubbe med texten Game over på.


Jag har avsiktligt valt att göra ett program helt utan pekare, struct eller class. Som synes blir koden både lång och svår att komma igenom. Det var så här man var tvungen att göra innan det fanns objektorienterad programmering, och ett litet enkelt program kunde svämma över alla sina bräddar när det gällde källkod.

Sättet att arbeta på var att man fick förlita sig på: globala variabler, funktioner och olika listor. Om man hade behov av att något på spelplanen både hade ett nummervärde och en text fick man ha två listor så att nummervärdet i nummerlista[23] blev samma som textvärdet i textlista[23]. Sedan kunde man styra innehållet med positionen i listan. Jag hittade bara på siffran 23 för att ha som exempel. Hade man många olika typer av värden fick man lägga in dem i olika listor, ibland 7-8 stycken. Listor med flera värden av samma variabeltyp fick man stället göra som matriser.

Så, tanken bakom spelet är ett enkelt hänga gubben spel.

  • När spelet börjar öppnar sig en svart ruta där man fyller i ett ord. Tryck enter så kan man gissa.
  • Gissar man fel läggs ytterligare en bit till hängningen.
  • Gissar man rätt kommer man att se bokstaven istället för ett streck.
  • Förlorar man står det game over.
  • Vinner man visas det hemliga ordet upp på svart botten.

Det låter enkelt, men här är källkoden, alla drygt 500 raderna.

//Bakgrundsbild http://photo.jv2.net/gallery/images/03__Manipulated_Photos/Dusk.jpg 
//omdöpt till bakgrund.jpg

 #include <iostream>
 #include <string>
 #include <sstream> //För att kunna konvertera siffror till text
 #include <SFML\System.hpp>
 #include <SFML\Window.hpp>
 #include <SFML\Graphics.hpp>
 // #include <SFML\Audio.hpp> bara om du vill ha ljud
 using namespace std;    // utifall att konsollen behövs för felsöknning

 //Funktioner som används*****************************************************************
string Int2String(int siffrain); //För att förvandla siffror till text

string bokstavsrad(char referens[], int kontroll[], int laengd, bool hemligt); //För att jämföra en array
	              //med integers mot en array med bokstäver och skapar en textsträng ut
                 //Längd är 255 för hemligt ord
                 //Om hemligt = true skrivs streck ut istället

char lower2upper(char bokstav); //För att se till så att enbart stora bokstäver
                                //kommer in i systemet.


//Kolla om man valt alla bokstäverna i det valda ordet
bool allavalda(int referens[], int referenslaengd);

bool finnstecknet(char referens[], char bokstav, int referenslaengd);
//För att se om en inskriven bokstav finns i en array med bokstäver, default true
//Så att man kan börja skriva vid programstart


int main()
{ //programstart

	//Vi måste få svenska tecken att fungera i hängagubbe programmet
	locale swedish("swedish");
   locale::global(swedish);

	//Ladda in ett typsnitt
	  sf::Font hangmanfont; //ladda en tom font
     if (!hangmanfont.LoadFromFile("comic.ttf", 50)) return EXIT_FAILURE; 
	  //Se till så att comoic.ttf finns i samma mapp som main.cpp

	  sf::String bokstavsval; //skapa en textremsa för valda bokstäver
	  sf::String hemligtord;//skapa en textremsa för det hemliga ordet

	    sf::RenderWindow App(sf::VideoMode(800, 600, 32), "SFML Hänga gubbe"); // Skapa fönstret vi skall ha spelet i
		int hangmannummer = 1; //Bestämmer vilken bild av de 13 som finns på
		                       //hängagubbe som visas, börja med bild 1
		double musX = 0.0; //När musen trycks ner
		double musY = 0.0; //När musen trycks ner

		int i = 0; //Räknar  igenom bokstävernas plats i Y-led
		int j = 0; //Räknar  igenom bokstävernas plats i X-led
		int hemligt_i = 0; //Räknare för bokstäver i hemligt ord.
       int hemligt_i_p = 0; //den position man har i ledet i hemligt i
		char hemlig_bokstav = 'Ü'; //Behövs för att validera varje bokstav användaren skriver in

		char valdbokstav = 'Ü'; //Vilken bokstav är vald av publiken?
		bool visahemligtord=true; //Visa den svarta textrutan från början

		string tempChar2String=""; //Behövs för att skapa en string av char i valda bokstäver

	//Skapa en array för alfabetet
	char alfabetet[30] = {'A','B','C','D','E','F','G','H','I','J',
		                  'K','L','M','N','O','P','Q','R','S','T',
	                      'U','V','W','X','Y','Z','Å','Ä','Ö','-'};
	int valdabokstaver[30] ={0}; //Här hamnar de bokstäver vi valt
	                             //vald bokstav blir 1 vid val


	char skrivetord[255] = ""; //Här hamnar det ord man valt, max 254 tecken långt +  \0

	int skrivetord_referens[255]={0}; //0 = har inte valt 1 = har valt
	                                 //så att den blir synlig

	float bokstavsposition[30][2]; //arrays definieras med Y-X i detta undantag
	                             //Förutsätter att brickorna är 60x60
	bokstavsposition[0][0] = 0.0; bokstavsposition[0][1] = 0.0; //X och Y för bokstaven A
	bokstavsposition[1][0] = 60.0; bokstavsposition[1][1] = 0.0; //X och Y för bokstaven B
	bokstavsposition[2][0] = 120.0; bokstavsposition[2][1] = 0.0; //X och Y för bokstaven C

	bokstavsposition[3][0] = 0.0; bokstavsposition[3][1] = 60.0; //X och Y för bokstaven D
	bokstavsposition[4][0] = 60.0; bokstavsposition[4][1] = 60.0; //X och Y för bokstaven E
	bokstavsposition[5][0] = 120.0; bokstavsposition[5][1] = 60.0; //X och Y för bokstaven F

	bokstavsposition[6][0] = 0.0; bokstavsposition[6][1] = 120.0; //X och Y för bokstaven G
	bokstavsposition[7][0] = 60.0; bokstavsposition[7][1] = 120.0; //X och Y för bokstaven H
	bokstavsposition[8][0] = 120.0; bokstavsposition[8][1] = 120.0; //X och Y för bokstaven I

	bokstavsposition[9][0] = 0.0; bokstavsposition[9][1] = 180.0; //X och Y för bokstaven J
	bokstavsposition[10][0] = 60.0; bokstavsposition[10][1] = 180.0; //X och Y för bokstaven K
	bokstavsposition[11][0] = 120.0; bokstavsposition[11][1] = 180.0; //X och Y för bokstaven L

	bokstavsposition[12][0] = 0.0; bokstavsposition[12][1] = 240.0; //X och Y för bokstaven M
	bokstavsposition[13][0] = 60.0; bokstavsposition[13][1] = 240.0; //X och Y för bokstaven N
	bokstavsposition[14][0] = 120.0; bokstavsposition[14][1] = 240.0; //X och Y för bokstaven O

	bokstavsposition[15][0] = 0.0; bokstavsposition[15][1] = 300.0; //X och Y för bokstaven P
	bokstavsposition[16][0] = 60.0; bokstavsposition[16][1] = 300.0; //X och Y för bokstaven Q
	bokstavsposition[17][0] = 120.0; bokstavsposition[17][1] = 300.0; //X och Y för bokstaven R

	bokstavsposition[18][0] = 0.0; bokstavsposition[18][1] = 360.0; //X och Y för bokstaven S
	bokstavsposition[19][0] = 60.0; bokstavsposition[19][1] = 360.0; //X och Y för bokstaven T
	bokstavsposition[20][0] = 120.0; bokstavsposition[20][1] = 360.0; //X och Y för bokstaven U

	bokstavsposition[21][0] = 0.0; bokstavsposition[21][1] = 420.0; //X och Y för bokstaven V
	bokstavsposition[22][0] = 60.0; bokstavsposition[22][1] = 420.0; //X och Y för bokstaven W
	bokstavsposition[23][0] = 120.0; bokstavsposition[23][1] = 420.0; //X och Y för bokstaven X

	bokstavsposition[24][0] = 0,0; bokstavsposition[24][1] = 480.0; //X och Y för bokstaven Y
	bokstavsposition[25][0] = 60.0; bokstavsposition[25][1] = 480.0; //X och Y för bokstaven Z
	bokstavsposition[26][0] = 120.0; bokstavsposition[26][1] = 480.0; //X och Y för bokstaven Å

	bokstavsposition[27][0] = 0.0; bokstavsposition[27][1] = 540.0; //X och Y för bokstaven Ä
	bokstavsposition[28][0] = 60.0; bokstavsposition[28][1] = 540.0; //X och Y för bokstaven Ö
	bokstavsposition[29][0] = 120.0; bokstavsposition[29][1] = 540.0; //X och Y för bokstaven -

	
	//Ladda in alla bilderna för bokstäverna
sf::Image A; //Bokstaven A
 A.LoadFromFile("A.jpg");
sf::Image B; //Bokstaven B
B.LoadFromFile("B.jpg");
sf::Image C; //Bokstaven C
C.LoadFromFile("C.jpg");
sf::Image D; //Bokstaven D
D.LoadFromFile("D.jpg");
sf::Image E; //Bokstaven E
E.LoadFromFile("E.jpg");
sf::Image F; //Bokstaven F
F.LoadFromFile("F.jpg");
sf::Image G; //Bokstaven G
G.LoadFromFile("G.jpg");
sf::Image H; //Bokstaven H
H.LoadFromFile("H.jpg");
sf::Image I; //Bokstaven I
I.LoadFromFile("I.jpg");
sf::Image J; //Bokstaven J
J.LoadFromFile("J.jpg");

sf::Image K; //Bokstaven K
K.LoadFromFile("K.jpg");
sf::Image L; //Bokstaven L
L.LoadFromFile("L.jpg");
sf::Image M; //Bokstaven M
M.LoadFromFile("M.jpg");
sf::Image N; //Bokstaven N
N.LoadFromFile("N.jpg");
sf::Image O; //Bokstaven O
O.LoadFromFile("O.jpg");
sf::Image P; //Bokstaven P
P.LoadFromFile("P.jpg");
sf::Image Q; //Bokstaven Q
Q.LoadFromFile("Q.jpg");
sf::Image R; //Bokstaven R
R.LoadFromFile("R.jpg");
sf::Image S; //Bokstaven S
S.LoadFromFile("S.jpg");
sf::Image T; //Bokstaven T
T.LoadFromFile("T.jpg");

sf::Image U; //Bokstaven U
U.LoadFromFile("U.jpg");
sf::Image V; //Bokstaven V
V.LoadFromFile("V.jpg");
sf::Image W; //Bokstaven W
W.LoadFromFile("W.jpg");
sf::Image X; //Bokstaven X
X.LoadFromFile("X.jpg");
sf::Image Y; //Bokstaven Y
Y.LoadFromFile("Y.jpg");
sf::Image Z; //Bokstaven Z
Z.LoadFromFile("Z.jpg");
sf::Image AO; //Bokstaven Å
AO.LoadFromFile("AO.jpg");
sf::Image AE; //Bokstaven Ä
AE.LoadFromFile("AE.jpg");
sf::Image OE; //Bokstaven Ö
OE.LoadFromFile("OE.jpg");
sf::Image _; //Bokstaven -
_.LoadFromFile("_.jpg");

//Ladda in hangman bilderna*******************************************************************************
sf::Image Hangmanbild; //Kullen

string hangmanfilnummer; //Vi vill få fram nummer till text
hangmanfilnummer =  Int2String(hangmannummer); //Den bild i nummerordning som finns 1-13 skall visas
string hangmanfilnamn = hangmanfilnummer + ".png"; //bildnumret får filens namnslut
Hangmanbild.LoadFromFile(hangmanfilnamn); //Laddar in den bild som spriten skall visa


//Ladda in bakgrundsbild***************************************
sf::Image bakgrund; //Bakgrundsbild
bakgrund.LoadFromFile("bakgrund.jpg");

 sf::Sprite Bakgrundssprite(bakgrund); //skapa sprite för bakgrund
Bakgrundssprite.SetPosition(0,0); //Placera ut 

//Koppla bilderna till individuella sprites
sf::Sprite SpriteA(A); //skapa sprite för bild A
SpriteA.SetPosition(bokstavsposition[0][0], bokstavsposition[0][1]); //Placera ut 
sf::Sprite SpriteB(B); //skapa sprite för bild B
SpriteB.SetPosition(bokstavsposition[1][0], bokstavsposition[1][1]); //Placera ut spriten
sf::Sprite SpriteC(C); //skapa sprite för bild C
SpriteC.SetPosition(bokstavsposition[2][0], bokstavsposition[2][1]); //Placera ut spriten


 sf::Sprite SpriteD(D); //skapa sprite för bild D
SpriteD.SetPosition(bokstavsposition[3][0], bokstavsposition[3][1]); //Placera ut 
sf::Sprite SpriteE(E); //skapa sprite för bild E
SpriteE.SetPosition(bokstavsposition[4][0], bokstavsposition[4][1]); //Placera ut spriten
sf::Sprite SpriteF(F); //skapa sprite för bild F
SpriteF.SetPosition(bokstavsposition[5][0], bokstavsposition[5][1]); //Placera ut spriten

  sf::Sprite SpriteG(G); //skapa sprite för bild G
SpriteG.SetPosition(bokstavsposition[6][0], bokstavsposition[6][1]); //Placera ut 
sf::Sprite SpriteH(H); //skapa sprite för bild H
SpriteH.SetPosition(bokstavsposition[7][0], bokstavsposition[7][1]); //Placera ut spriten
sf::Sprite SpriteI(I); //skapa sprite för bild I
SpriteI.SetPosition(bokstavsposition[8][0], bokstavsposition[8][1]); //Placera ut spriten

  sf::Sprite SpriteJ(J); //skapa sprite för bild J
SpriteJ.SetPosition(bokstavsposition[9][0], bokstavsposition[9][1]); //Placera ut 
sf::Sprite SpriteK(K); //skapa sprite för bild K
SpriteK.SetPosition(bokstavsposition[10][0], bokstavsposition[10][1]); //Placera ut spriten
sf::Sprite SpriteL(L); //skapa sprite för bild L
SpriteL.SetPosition(bokstavsposition[11][0], bokstavsposition[11][1]); //Placera ut spriten

  sf::Sprite SpriteM(M); //skapa sprite för bild M
 SpriteM.SetPosition(bokstavsposition[12][0], bokstavsposition[12][1]); //Placera ut 
sf::Sprite SpriteN(N); //skapa sprite för bild N
SpriteN.SetPosition(bokstavsposition[13][0], bokstavsposition[13][1]); //Placera ut spriten
sf::Sprite SpriteO(O); //skapa sprite för bild O
SpriteO.SetPosition(bokstavsposition[14][0], bokstavsposition[14][1]); //Placera ut spriten

  sf::Sprite SpriteP(P); //skapa sprite för bild P
SpriteP.SetPosition(bokstavsposition[15][0], bokstavsposition[15][1]); //Placera ut 
sf::Sprite SpriteQ(Q); //skapa sprite för bild Q
SpriteQ.SetPosition(bokstavsposition[16][0], bokstavsposition[16][1]); //Placera ut spriten
sf::Sprite SpriteR(R); //skapa sprite för bild R
SpriteR.SetPosition(bokstavsposition[17][0], bokstavsposition[17][1]); //Placera ut spriten

  sf::Sprite SpriteS(S); //skapa sprite för bild S
SpriteS.SetPosition(bokstavsposition[18][0], bokstavsposition[18][1]); //Placera ut 
sf::Sprite SpriteT(T); //skapa sprite för bild T
SpriteT.SetPosition(bokstavsposition[19][0], bokstavsposition[19][1]); //Placera ut spriten
sf::Sprite SpriteU(U); //skapa sprite för bild U
SpriteU.SetPosition(bokstavsposition[20][0], bokstavsposition[20][1]); //Placera ut spriten

  sf::Sprite SpriteV(V); //skapa sprite för bild V
SpriteV.SetPosition(bokstavsposition[21][0], bokstavsposition[21][1]); //Placera ut 
sf::Sprite SpriteW(W); //skapa sprite för bild W
SpriteW.SetPosition(bokstavsposition[22][0], bokstavsposition[22][1]); //Placera ut spriten
sf::Sprite SpriteX(X); //skapa sprite för bild X
SpriteX.SetPosition(bokstavsposition[23][0], bokstavsposition[23][1]); //Placera ut spriten

  sf::Sprite SpriteY(Y); //skapa sprite för bild Y
SpriteY.SetPosition(bokstavsposition[24][0], bokstavsposition[24][1]); //Placera ut 
sf::Sprite SpriteZ(Z); //skapa sprite för bild Z
SpriteZ.SetPosition(bokstavsposition[25][0], bokstavsposition[25][1]); //Placera ut spriten
sf::Sprite SpriteAO(AO); //skapa sprite för bild Å
SpriteAO.SetPosition(bokstavsposition[26][0], bokstavsposition[26][1]); //Placera ut spriten

  sf::Sprite SpriteAE(AE); //skapa sprite för bild Ä
SpriteAE.SetPosition(bokstavsposition[27][0], bokstavsposition[27][1]); //Placera ut 
sf::Sprite SpriteOE(OE); //skapa sprite för bild Ö
SpriteOE.SetPosition(bokstavsposition[28][0], bokstavsposition[28][1]); //Placera ut spriten
sf::Sprite Sprite_(_); //skapa sprite för bild -
Sprite_.SetPosition(bokstavsposition[29][0], bokstavsposition[29][1]); //Placera ut spriten


//Koppla in hangmanbilden till sprite
sf::Sprite Hangman1(Hangmanbild); //skapa sprite för första bilden
Hangman1.SetPosition(181,0); //Placera ut kullen på spelplanen


	         while (App.IsOpened())  // Start spel-loopen
      {  //spel loopen börjar

		             sf::Event Event; 

            while (App.GetEvent(Event)) // Ta hand om händelser 
            { //Händelser från tangentbord och mus
				
				 	if ( Event.Type == sf::Event::TextEntered && visahemligtord==true)
                      { //Skriver in text
						  		 
						   hemlig_bokstav = lower2upper((char)Event.Text.Unicode);
						   if (finnstecknet(alfabetet,hemlig_bokstav, 30) == true)
						   {
							skrivetord[hemligt_i] = hemlig_bokstav; //Fyll i den godkända bokstaven i textraden
							 hemligt_i++; //Vill du veta antalet bokstäver i hemligt ord finns det här nu
						   }
						
                     }//slut skriver in text
					
					 //***********************************
					

               if (Event.Type == sf::Event::Closed) //kryssat på [x] symbolen? stäng programmet
               App.Close(); 
					
               if (Event.Type == sf::Event::KeyPressed) // En tangent har tryckts ner
                { //om det är en tangent som tryckts ner


                 if (Event.Key.Code == sf::Key::Escape) // ESC tangenten = stäng programmet
                      App.Close(); 

				  if (Event.Key.Code == sf::Key::Return) // Return/enter
					 {//Entertangent
						 if (visahemligtord==false) //shifta om man kan se eller inte se texten
							 visahemligtord=true;
						     else
							 visahemligtord=false;
						
					 }//Slut på entertangent
                  } //slut om det är en tangent som tryckts ner

//*************************************************************************************
// Mushändelser
//*************************************************************************************
              if (Event.Type == sf::Event::MouseButtonPressed) // En musknapp har tryckts ner
				        
			   {//musknapp, vilken som helst
	          if (Event.MouseButton.Button == sf::Mouse::Left)
	         { //vänster musknapp
	               musX = App.GetInput().GetMouseX(); //Var klickar vi med musen
				   musY = App.GetInput().GetMouseY(); 
				   i=0;//var säker på att i och j är 0
				   j=0;//var säker på att i och j är 0

				 while (i < 30)
				 {//Hoppa ner i Y-led
					 j=0;//placera xled pekaren på cell 0
					 while (j < 2)
					 { //Räkna i y led
						 //Räkna de två cellerna
						 if (musX > bokstavsposition[i][0] && musX < bokstavsposition[i][0] + 59) //Vi klickar på rätt i xled
						 {//rätt i x-led

							 if (musY > bokstavsposition[i][1] &&  musY < bokstavsposition[i][1] + 59 )
							 { //Här hittar vi rätt bokstav
								 valdabokstaver[i] = 1; //Ställ om bokstaven från ovald 0, till vald 1 i int array

								 valdbokstav = alfabetet[i]; //Ge valdbokstav rätt bokstav.
								                            //Variabeln tilldelas två gånger
								                            //Både för Y och X-led, men den blir alltid samma bokstav
								 
								 //Kontrollera om den valda bokstaven finns i det valda ordet
								 //Vi måste göra bokstaven synlig om så är fallet
									 while (hemligt_i_p <= hemligt_i) 
                                                //Så längeräknaren är mindre eller lika med antalet bokstäver i det hemliga ordet
                                      {
                                      if (valdbokstav == skrivetord[hemligt_i_p]) //Om bostäverna är likadana
										                                            //Man har valt en bokstav som finns i hemligt ord

                                         {
                                         skrivetord_referens[hemligt_i_p] = 1;//Ställ om referens array från 0 till 1
										  //Finns bokstaven, blir kontroll array lika med 1
                                          }


                                       hemligt_i_p ++;//Gå vidare
                                       }

						
								 hemligt_i_p =0; //Återställ till 0 så att den pekar på första bokstaven igen


							 }// slut Här hittar vi rätt bokstav

						 }//rätt i x-led
						j++; //Gå vidare i Y-led
					 }//Slut Räkna i y led
					 i++;
				 } //X-led pekaren har kommit till botten

				 //Kolla om den valda bokstaven finns i det hemliga ordet
				 if (finnstecknet(skrivetord, valdbokstav, hemligt_i-1)== false)///fanns inte

                   { //vad händer om man gissar fel?

                  if (hangmannummer < 13)//Ändra bilden till nästa, gå inte över 13
                     {
                       hangmannummer = hangmannummer+1;//växla till nästa bild
					    hangmanfilnummer =  Int2String(hangmannummer); //Den bild i nummerordning som finns 1-13 skall visas
                       string hangmanfilnamn = hangmanfilnummer + ".png"; //bildnumret får filens namnslut
                       Hangmanbild.LoadFromFile(hangmanfilnamn); //Laddar in den bild som spriten skall visa
						  }


                    }//Slut vad händer om man gissar fel?

				 //Vad händer om man gissat alla bokstäverna?
				if(allavalda(skrivetord_referens, hemligt_i)== true)//Man har valt alla bokstäver i ordet
				{
					if (hangmannummer < 13)
					visahemligtord=true;
				}

				
              	} //slut vänster musknapp

			   }//Slut Musknapp
			  
	

			 } //Händelser från tangentbord och mus

			     //rensa allt i fönstret och ersätt med blå färg
		         App.Clear(sf::Color(0, 0, 255)); 

				 //Rita upp bakgrunden
				App.Draw(Bakgrundssprite); 

				//Rita ut en grön rektangel som underdel
				App.Draw(sf::Shape::Rectangle(0, 360, 800, 600, sf::Color(95, 182, 77) )); 


				//Om man klickat på en bokstav skall den inte synas
				if (valdabokstaver[0] == 0)
                App.Draw(SpriteA); //Rita upp figuren på den yta spelaren ser
				if (valdabokstaver[1] == 0)
				 App.Draw(SpriteB); //Rita upp figuren på den yta spelaren ser
				if (valdabokstaver[2] == 0)
				 App.Draw(SpriteC); //Rita upp figuren på den yta spelaren ser
	

				if (valdabokstaver[3] == 0)
				 App.Draw(SpriteD); //Rita upp figuren på den yta spelaren ser
				if (valdabokstaver[4] == 0)
				 App.Draw(SpriteE); //Rita upp figuren på den yta spelaren ser
				if (valdabokstaver[5] == 0)
				 App.Draw(SpriteF); //Rita upp figuren på den yta spelaren ser
		

				if (valdabokstaver[6] == 0)
				 App.Draw(SpriteG); //Rita upp figuren på den yta spelaren ser
				if (valdabokstaver[7] == 0)
				 App.Draw(SpriteH); //Rita upp figuren på den yta spelaren ser
				 if (valdabokstaver[8] == 0)
				 App.Draw(SpriteI); //Rita upp figuren på den yta spelaren ser

				 if (valdabokstaver[9] == 0)
				  App.Draw(SpriteJ); //Rita upp figuren på den yta spelaren ser
				 if (valdabokstaver[10] == 0)
				 App.Draw(SpriteK); //Rita upp figuren på den yta spelaren ser
				 if (valdabokstaver[11] == 0)
				 App.Draw(SpriteL); //Rita upp figuren på den yta spelaren 

				 if (valdabokstaver[12] == 0)
				 App.Draw(SpriteM); //Rita upp figuren på den yta spelaren ser
				 if (valdabokstaver[13] == 0)
				 App.Draw(SpriteN); //Rita upp figuren på den yta spelaren ser
				 if (valdabokstaver[14] == 0)
				 App.Draw(SpriteO); //Rita upp figuren på den yta spelaren ser
				
				 if (valdabokstaver[15] == 0)
				 App.Draw(SpriteP); //Rita upp figuren på den yta spelaren ser
				 if (valdabokstaver[16] == 0)
				 App.Draw(SpriteQ); //Rita upp figuren på den yta spelaren ser
				 if (valdabokstaver[17] == 0)
				 App.Draw(SpriteR); //Rita upp figuren på den yta spelaren ser

				 if (valdabokstaver[18] == 0)
				 App.Draw(SpriteS); //Rita upp figuren på den yta spelaren ser
				 if (valdabokstaver[19] == 0)
				 App.Draw(SpriteT); //Rita upp figuren på den yta spelaren ser
				 if (valdabokstaver[20] == 0)
				 App.Draw(SpriteU); //Rita upp figuren på den yta spelaren ser

				 if (valdabokstaver[21] == 0)
				 App.Draw(SpriteV); //Rita upp figuren på den yta spelaren ser
				 if (valdabokstaver[22] == 0)
				 App.Draw(SpriteW); //Rita upp figuren på den yta spelaren ser
				 if (valdabokstaver[23] == 0)
				 App.Draw(SpriteX); //Rita upp figuren på den yta spelaren ser

				 if (valdabokstaver[24] == 0)
				 App.Draw(SpriteY); //Rita upp figuren på den yta spelaren ser
				 if (valdabokstaver[25] == 0)
				 App.Draw(SpriteZ); //Rita upp figuren på den yta spelaren ser
				 if (valdabokstaver[26] == 0)
				 App.Draw(SpriteAO); //Rita upp figuren på den yta spelaren ser

				 if (valdabokstaver[27] == 0)
				 App.Draw(SpriteAE); //Rita upp figuren på den yta spelaren ser
				 if (valdabokstaver[28] == 0)
				 App.Draw(SpriteOE); //Rita upp figuren på den yta spelaren ser
				 if (valdabokstaver[29] == 0)
				 App.Draw(Sprite_); //Rita upp figuren på den yta spelaren ser


                  //Skriv ut hemligt ord under kullen
                                tempChar2String="";
								tempChar2String=bokstavsrad(skrivetord, skrivetord_referens, hemligt_i-1, true);
								hemligtord.SetText(tempChar2String);
								hemligtord.SetFont(hangmanfont);
								hemligtord.SetPosition(180.f, 420.f); //placera ut texten under kullen
                  //Skriv ut hemligt ord i den svarta textrutan
								if (visahemligtord==true)
								{
							    tempChar2String="";
								tempChar2String=bokstavsrad(skrivetord, skrivetord_referens, hemligt_i-1, false);
								hemligtord.SetText(tempChar2String);
								hemligtord.SetFont(hangmanfont);
								hemligtord.SetPosition(210.f, 410.f); //placera ut texten i textrutan
								}
				 //Rita upp hängagubbe bilden
				  App.Draw(Hangman1); //Rita upp figuren på den yta spelaren ser
				  	     if (visahemligtord==true)
						 {//Visa hemligt ord
						//Rita ut en svart rektangel som textarea när man skriver i det hemliga ordet
					     App.Draw(sf::Shape::Rectangle(183, 398, 797, 452, sf::Color(255, 0, 0) )); //Ram, röd 
                         App.Draw(sf::Shape::Rectangle(185, 400, 795, 450, sf::Color(0, 0, 0) )); //svart ruta
					      }//visa hemligt ord
				  App.Draw(bokstavsval); //rita ut de valda bokstäverna
				  App.Draw(hemligtord); //Rita ut det hemliga ordet

                  App.Display(); //visa upp ändringarna för användaren

			 } //spelloopen slutar
        return 0;
}//programslut

//Kontrollera om en bokstav finns i en array, så att man inte lägger in kontrolltecken o dyl.
bool finnstecknet(char referens[], char bokstav, int referenslaengd)
	//referens[] blir vanligtvis alfabetet
	//bokstav är en bokstav användaren tryycker ner på tangentbordet
	//referenslängd är hur långt i en array ,man skall söka, 30 för alfabetet
{ 
	int i = 0;
	bool ut = false;

	while (i <= referenslaengd)
	{
		if (referens[i]==bokstav)
			ut = true;
		i++;
	}
	return ut;

} 

//Kolla om man valt alla bokstäverna i det valda ordet
bool allavalda(int referens[], int referenslaengd)
{ bool tempbool=false;
	int i = 0;
	int slutsiffra = 0;
	while (i < referenslaengd)
	{

		if (referens[i] == 1)
         {//om det är en etta
		slutsiffra = slutsiffra+1;
		 }		
		i++;
	}

	if (slutsiffra == referenslaengd)
		//Om alla var ettor
		tempbool=true;
	//annars
	return tempbool;
} 
//Skriva ut bokstäver utifrån en sifferreferens*****************************'
string bokstavsrad(char referens[], int kontroll[], int laengd, bool hemligt)
	//referens[]= Kan endera vara de bokstäver man valt genom att klicka på bildrutorna
	               //eller den array man får från det hemliga ordet.
	//kontroll[]= Visar om en bokstav är vald eller inte (1 eller 0)
	             //för bokstavsrutorna visar det iom rutan skall synas eller ej
				 //för hemligt ord avgör det om man skall visa bokstav eller streck
	//laengd= Så många bokstäver i ordet som finns i listan, hemligt ord = hemligt_i 
	//hemligt= Är det det hemliga ordet skall vi bara visa bokstäver som är valda, resten blir streck
{ 
int i = 0; //raknare
string tempstring=""; //temporär string

   while (i <= laengd) // de i hemligt ord
  { //while
	   
	    if ( hemligt == true  )
		   //kontrollen visar att den inte är vald och hemligt är true och man inte är vid ordslut
	   { //man vill hålla ej valda bokstäver hemliga
		  if ( kontroll[i] == 0 )
		   tempstring = tempstring +" "+ '_'+" ";
		  else
           tempstring = tempstring + " " + referens[i] +" ";
	   }

         else if (hemligt == false)
		   //kontrollen visar att den inte är vald och hemligt är falskt (man skriver just in texten) och man inte är vid ordslut
	   { //man vill visa alla bokstäverna i det hemliga ordet.

		  //if (kontroll[i] == 1)
		   tempstring = tempstring + referens[i];
	   }

   i = i+1;
  }//while

return tempstring;
}//****************************************************************************

string Int2String(int siffrain)//**********************************************
{    //Förvandlar ett tal till text
	//Detta kräver: #include <sstream>
	// och: using namespace std; 
 std::string s;
std::stringstream out;
out << siffrain;
s = out.str();
return s;
}//*****************************************************************************

//För att "tvätta" bokstäver så att 
//inga gemener kommer in i orden
char lower2upper(char bokstav) //***********************************************
{
if (bokstav == 'a')
   bokstav ='A';
if (bokstav == 'b')
   bokstav ='B';
if (bokstav == 'c')
   bokstav ='C';

if (bokstav == 'd')
   bokstav ='D';
if (bokstav == 'e')
   bokstav ='E';
if (bokstav == 'f')
   bokstav ='F';

if (bokstav == 'g')
   bokstav ='G';
if (bokstav == 'h')
   bokstav ='H';
if (bokstav == 'i')
   bokstav ='I';

if (bokstav == 'j')
   bokstav ='J';
if (bokstav == 'k')
   bokstav ='K';
if (bokstav == 'l')
   bokstav ='L';

if (bokstav == 'm')
   bokstav ='M';
if (bokstav == 'n')
   bokstav ='N';
if (bokstav == 'o')
   bokstav ='O';

if (bokstav == 'p')
   bokstav ='P';
if (bokstav == 'q')
   bokstav ='Q';
if (bokstav == 'r')
   bokstav ='R';

if (bokstav == 's')
   bokstav ='S';
if (bokstav == 't')
   bokstav ='T';
if (bokstav == 'u')
   bokstav ='U';

if (bokstav == 'v')
   bokstav ='V';
if (bokstav == 'w')
   bokstav ='W';
if (bokstav == 'x')
   bokstav ='X';

if (bokstav == 'y')
   bokstav ='Y';
if (bokstav == 'z')
   bokstav ='Z';
if (bokstav == 'å')
   bokstav ='Å';
if (bokstav == 'ä')
   bokstav ='Ä';
if (bokstav == 'ö')
   bokstav ='Ö';

return bokstav;
}

//Slut på funktionerna