Keskustelu: Ohjelmointikysymykset: C++: Ei voida avata kuvaa

#include "ohjelma.hpp"
#include <iostream>
#include <stdexcept>
#include <SDL/SDL.h>

namespace ohjelma {
	static SDL_Surface *ruutu;
	static void piirra_kuva(SDL_Surface *kuva, int x, int y, bool keskikohta = false);
	namespace kuvat {
		static SDL_Surface *lataa(const char *nimi, bool lapinakyva);

		static SDL_Surface *tausta_valikko;
	}
}
kuvat::tausta_valikko = kuvat::lataa("grafiikka/valikko_tausta.bmp", true);


static SDL_Surface *ohjelma::kuvat::lataa(const char *nimi, bool lapinakyva) {

	if (SDL_Surface *tmp = SDL_LoadBMP(nimi)) {
		if (SDL_Surface *opti = SDL_DisplayFormat(tmp)) {
			SDL_FreeSurface(tmp);
			tmp = opti;
		}
		if (lapinakyva) {
			SDL_SetColorKey(tmp, SDL_SRCCOLORKEY, SDL_MapRGB(tmp->format, 255, 255, 255));
		}
		return tmp;
	}
	throw std::runtime_error(SDL_GetError());
}

//peli.hpp
#ifndef _PELI_HPP
#define _PELI_HPP


namespace peli {
    int aja();

	struct alue {
		int x0, y0, x1, y1;
	};

    struct lifepack {
        float x, y;
    };
    struct enemy {
        float x, y;
    };
    struct point {
        float x, y;
    };
    struct pelaaja {
            struct timo {
            float x, y;
            float x0, y0;
			timo *nenampi, *hannampi;
        };
        timo *nena, *hanta;
        float suunta, vaihe, elama;
    };
}

#endif

//peli.cpp


namespace peli {
	// Pienin aikamäärä, jonka kello etenee. Liian lyhyt väli vaatii paljon
	// tehoa. Matopelissä 0.02 (eli 2 / 100) sekuntia on tarpeeksi lyhyt.
	static const float ajan_muutos = 0.02;
	static const float elama=100;
	static pelaaja uusi_mato();

}

peli::pelaaja peli::uusi_mato() {
	pelaaja m;
	m.elama=100; //yritin tässä saada alustettua elama muuttujaa, mutta ei auttanut, koska errori on piirtofunktiossa.
	m.suunta = m.vaihe = 0;
	m.nena = m.hanta = new pelaaja::timo; //täällä on jotain kopioitu koska tutustun näiden toimintaan.
	m.nena->nenampi = m.hanta->hannampi = 0;
	m.nena->x = m.nena->x0 = (pelialue.x0 + pelialue.x1) / 2;
	m.nena->y = m.nena->y0 = (pelialue.y0 + pelialue.y1) / 2;
	return m;
}

//ohjelma.cpp
//ohjelma.hpp on tismalleen samallainen kuin matopelissä.
//ja tästä puuttuu kaikki muut funktiot paitsi piirto, jotta pysyisi tässä foorumissa siistiniä.

namespace ohjelma {
	// Staattisia, siis vain tämän tiedoston käyttöön.
	static SDL_Surface *ruutu;
	static void piirra_kuva(SDL_Surface *kuva, int x, int y, bool keskikohta = false);
	namespace kuvat {
		static SDL_Surface *lataa(const char *nimi, bool lapinakyva);

		// Kuvat.
		static SDL_Surface *tausta_valikko;
		static SDL_Surface *valikko_peli, *valikko_peli_valittu;
		static SDL_Surface *valikko_lopetus, *valikko_lopetus_valittu;
		static SDL_Surface *saari, *PeliHahmo, *elamapaketti;
		static SDL_Surface *life, *notlife;
	}
}





void ohjelma::piirra_peli(peli::alue const& alue, peli::pelaaja const& pelaaja, peli::lifepack const& lifepack) {

	piirra_kuva(kuvat::saari, 0, 0);

	piirra_kuva(kuvat::notlife, 0, 0);
	for (float op=1; op <= m.elama; op++) //tässä tekeleeni
	{
        piirra_kuva(kuvat::life, op, 0);
	}
	const float yksikko_x = kuvat::PeliHahmo->w;
	const float yksikko_y = kuvat::PeliHahmo->h;

	// (Oletetaan, että alue mahtuu kerralla ruudulle!)
	const float keski_x = ruutu->w / 2 - yksikko_x * (alue.x0 + alue.x1) / 2;
	const float keski_y = ruutu->h / 2 - yksikko_y * (alue.y0 + alue.y1) / 2;

	for (peli::pelaaja::timo *j = pelaaja.hanta; j != 0; j = j->nenampi) {
		piirra_kuva(kuvat::PeliHahmo, keski_x + yksikko_x * j->x, keski_y + yksikko_y * j->y, true);
	}

	piirra_kuva(kuvat::elamapaketti, keski_x + yksikko_x * lifepack.x, keski_y + yksikko_y * lifepack.y, true);

	SDL_Flip(ruutu);
}

#include "peli.hpp"
#include "ohjelma.hpp"
#include <iostream>
#include <fcntl.h>
#include <cmath>
#include <io.h>
#include <cstdlib>
#include <ctime>
#include <SDL\SDL.h>

namespace peli {
	// Pienin aikamäärä, jonka kello etenee. Liian lyhyt väli vaatii paljon
	// tehoa. Matopelissä 0.02 (eli 2 / 100) sekuntia on tarpeeksi lyhyt.
	static const float ajan_muutos = 0.02;

	// Pelikentän rajat (x0, y0, x1, y1).
	static const alue pelialue = {-8, -6, 8, 6};

	// Jaokkeen ja omenan säteet, puoli yksikköä kummatkin.
	static const float jaokkeen_sade = 0.5, omenan_sade = 0.5;

	// Madon kääntymisnopeus radiaaneina sekunnissa, puoli kierrosta.
	static const float pii = 3.14159265358979323846;
	static const float kaannosnopeus = pii;

	static const float vaihenopeus = 2.7;
	static const float etenema = 0.65 * 2 * jaokkeen_sade;

	static const float matelun_heitto = 0.07;

	static const float elama=90;

	static pelaaja uusi_mato();
	static void tuhoa_mato(pelaaja& m);
	float angle(float cx, float cy, float px, float py, int Player_x, int Player_y, int Target_x, int Target_y);
	double rad2deg(double rad);
	static lifepack arvo_lifepack(pelaaja const& m);

	static void liikuta(pelaaja& m, bool oikealle, bool vasemmalle);
	static bool osuu_elamaan(pelaaja const& m, lifepack const& o);

	static inline float etaisyys(float x0, float y0, float x1, float y1) {
		float dx = x1 - x0, dy = y1 - y0;
		return std::sqrt(dx * dx + dy * dy);
	}
}

float peli::angle(float cx, float cy, float px, float py, int Player_x, int Player_y, int Target_x, int Target_y)
{
    float i;
    double ili=std::atan2((double)cx,(double)cy,(double)px,(double)py);
    i=ToDeg*ili;
    if (i<0)
    {
      return i+360;
    }
    else
    {
      return i;
    }
}

double peli::rad2deg(double rad){
    return ((rad * 180) / 3.1415927);
}





void peli::liikuta(pelaaja& m, bool oikealle, bool vasemmalle) {
    Uint8* nappi;
	//if (oikealle && !vasemmalle) {
		//m.suunta += ajan_muutos * kaannosnopeus;
	//} else if (vasemmalle && !oikealle) {
		//m.suunta -= ajan_muutos * kaannosnopeus;
	//}
        //kaikki yläpuolelta lähtee jos vaan saan tuon alapuolella olevan toimimaan:

	int hiiren_x, hiiren_y;
	hiiri=SDL_GetMouseState(&hiiren_x,&hiiren_y);
	int x_jana = (hiiren_x - m.nena->x);
	int y_jana = (hiiren_y - m.nena->y);
	double kulma = std::atan2((double)-y_jana, (double)x_jana);
	temp = rotozoomSurface(PeliHahmo, rad2deg(m.suunta), 1, 1);



    nappi = SDL_GetKeyState(NULL);
    if (nappi[SDLK_UP])
    {
	m.vaihe += ajan_muutos * vaihenopeus;
	while (m.vaihe >= 1)
	{
		m.vaihe -= 1;

		for (pelaaja::timo *j = m.hanta; j != m.nena; j = j->nenampi) {
			j->x0 = j->nenampi->x0;
			j->y0 = j->nenampi->y0;
		}
		m.nena->x0 += std::cos(m.suunta) * etenema;
		m.nena->y0 += std::sin(m.suunta) * etenema;
	}
            m.nena->x = m.nena->x0 + std::cos(m.suunta) * etenema * m.vaihe;
            m.nena->y = m.nena->y0 + std::sin(m.suunta) * etenema * m.vaihe;
    }
}

//peli.cpp
void peli::liikuta(pelaaja& m, bool oikealle, bool vasemmalle) {
    Uint8* nappi;

    float hiiri;
    int hiiren_x, hiiren_y;
    hiiri=SDL_GetMouseState(&hiiren_x,&hiiren_y);
	int x_jana = (hiiren_x - m.x);
	int y_jana = (hiiren_y - m.y);
	m.suunta = std::atan2((double)-y_jana, (double)x_jana);


    nappi = SDL_GetKeyState(NULL);
    if (nappi[SDLK_s])
    {
        m.y+=1;
    }
    if (nappi[SDLK_w])
    {
        m.y-=1;
    }
    if (nappi[SDLK_d])
    {
        m.x+=1;
    }
    if (nappi[SDLK_a])
    {
        m.x-=1;
    }
}

//ohjelma.cpp
#include "ohjelma.hpp"
#include <iostream>
#include <stdexcept>
#include <cmath>
#include <SDL/SDL.h>
#include <SDL_rotozoom.h>

namespace ohjelma {
	// Staattisia, siis vain tämän tiedoston käyttöön.
	static SDL_Surface *ruutu;
	static void piirra_kuva(SDL_Surface *kuva, int x, int y, bool keskikohta = false);
	namespace kuvat {
		static SDL_Surface *lataa(const char *nimi, bool lapinakyva);

		// Kuvat.
		static SDL_Surface *tausta_valikko;
		static SDL_Surface *valikko_peli, *valikko_peli_valittu;
		static SDL_Surface *valikko_lopetus, *valikko_lopetus_valittu;
		static SDL_Surface *saari, *PeliHahmo, *elamapaketti;
		static SDL_Surface *life, *notlife, *pistooli;
	}
}

void ohjelma::alku() {
	std::clog << "ohjelma::alku()" << std::endl;
	if (SDL_Init(SDL_INIT_VIDEO) != 0) {
		throw std::runtime_error(SDL_GetError());
	}
	ruutu = SDL_SetVideoMode(800, 600, 32, SDL_DOUBLEBUF|SDL_FULLSCREEN);
	if (!ruutu) {
		throw std::runtime_error(SDL_GetError());
	}
	SDL_WM_SetCaption("Timo ja Tomi - Saarella", "Timo ja Tomi - Saarella");

	kuvat::life = kuvat::lataa("data/grafiikka/life.bmp", false);
	kuvat::saari = kuvat::lataa("data/grafiikka/saari.bmp", false);
	kuvat::notlife = kuvat::lataa("data/grafiikka/notlife.bmp", false);
	kuvat::tausta_valikko = kuvat::lataa("data/grafiikka/valikko_tausta.bmp", true);
	kuvat::PeliHahmo = kuvat::lataa("data/grafiikka/peli_hahmo.bmp", true);
	kuvat::valikko_peli = kuvat::lataa("data/grafiikka/aloita_peli.bmp", true);
	kuvat::valikko_peli_valittu = kuvat::lataa("data/grafiikka/aloita_peli_valittu.bmp", true);
	kuvat::valikko_lopetus = kuvat::lataa("data/grafiikka/lopeta_peli.bmp", true);
	kuvat::valikko_lopetus_valittu = kuvat::lataa("data/grafiikka/lopeta_peli_valittu.bmp", true);
	kuvat::elamapaketti = kuvat::lataa("data/grafiikka/lifepack.bmp", true);
	kuvat::pistooli = kuvat::lataa("data/grafiikka/pistooli.bmp", true);

	// Nollataan sekuntilaskuri.
	sekunnit(true);
}

// Lataa kuvan ja optimoi sen piirtoa varten.
static SDL_Surface *ohjelma::kuvat::lataa(const char *nimi, bool lapinakyva) {
	// Jos lataus onnistuu...
	if (SDL_Surface *tmp = SDL_LoadBMP(nimi)) {
		// Yritetään optimoida.
		if (SDL_Surface *opti = SDL_DisplayFormat(tmp)) {
			// Tuhotaan alkuperäinen ja palautetaan optimoitu.
			SDL_FreeSurface(tmp);
			tmp = opti;
		}
		// Asetetaan läpinäkyvä väri (magenta eli pinkki).
		if (lapinakyva) {
			SDL_SetColorKey(tmp, SDL_SRCCOLORKEY, SDL_MapRGB(tmp->format, 255, 255, 255));
		}
		// Palautetaan kuva.
		return tmp;
	}
	// Muuten heitetään virhe.
	throw std::runtime_error(SDL_GetError());
}



void ohjelma::piirra_peli(peli::alue const& alue, peli::pelaaja const& pelaaja, peli::lifepack const& lifepack) {
	piirra_kuva(kuvat::saari, 0, 0);

	piirra_kuva(kuvat::notlife, 0, 0);
	for (float op=0; op <= pelaaja.elama; op++)
	{
        piirra_kuva(kuvat::life, op, 0);
	}
	if (pelaaja.ase==1)
	{
        piirra_kuva(kuvat::pistooli, 0, 30);
	}
	const float yksikko_x = kuvat::PeliHahmo->w;
	const float yksikko_y = kuvat::PeliHahmo->h;

	// Lasketaan lisättävä pikselimäärä, jotta pelialue tulee ruudun keskelle.
	// (Oletetaan, että alue mahtuu kerralla ruudulle!)
	const float keski_x = ruutu->w / 2 - yksikko_x * (alue.x0 + alue.x1) / 2;
	const float keski_y = ruutu->h / 2 - yksikko_y * (alue.y0 + alue.y1) / 2;
	SDL_Surface *temp;
	temp = rotozoomSurface(ohjelma::kuvat::PeliHahmo, rad2deg(pelaaja.suunta), 1, 1);
        piirra_kuva(temp, pelaaja.x - temp->w / 2, pelaaja.y - temp->h / 2, false);
        SDL_FreeSurface(temp);

	piirra_kuva(kuvat::elamapaketti, keski_x + yksikko_x * lifepack.x, keski_y + yksikko_y * lifepack.y, true);

	SDL_Flip(ruutu);
}