C++ Zmiana elementów tablicy.

0

Witam,

Piszę od jakiegoś czasu grę, ma ona być na zasadzie ( jest sobie coś co ma przejść na dół [w aktualnym ułożeniu monitora z lewej do prawej ] ) i między nim mają się poruszać przeszkody. to co ma przejść oznaczone jest literką j, to co jest przeszkodami zaznaczone jest literką x. Problem w tym że jeżeli korzystam z opcji rand() prawdopodobieństwo nie rozkłada się równo i poruszające przeszkody nie chodzą "Jak powinny", wpadłem na pomysł, że będą ciągle ruszać się w jedną stronę, lecz dalej coś nie działa. ( 2 próby zrobienia permutacji tablicy, żadne nie działa jak powinna ), dla pierwszej części w pliku funbocz.cpp trzeba zmienić z !=1 na ==3;

Poniżej zamieszczam kody wszystkiego. ( na samym dole kod w którym w/g mnie jest problem

main.cpp:

#include "../lib/funkcje.h"
#include "../lib/zmienne.h"

	bool Testowanie=true;

int main()
{

	srand(time(NULL));
	int dl;
	
	
	plansza statki;
	przeszkoda prz;
	prz.buduj(statki);
	jon j1;
	j1.buduj(statki,prz);
	
	clock_t start = clock();
	for(int i= 0; i <10; i++)
	{
	//	j1.ruch(statki,prz);
		statki.wyswietl();
		for(int i=1;i<poziomtab;i=i+2)
			prz.ruch(statki,i);
		czekaj(30);
	}
	cout << "   ";
	for (int i=0;i<47;i++)
	{
		if(CzyPuste(statki,i,24))
		   { cout << "0  ";}
		else
		   {cout << "1  ";}
	 }
/*	for (int i=0;i<25;i++)
	{
		cout << "Linia " <<i+1 << ": ";
		for(int j=0;j<47;j++)
		{
			cout << statki.wsk[i][j]->typ << "-";
			cout << prz.tablica[i][j]->typ << "  ";
		}
		cout << endl;
	}*/

		long duration = (clock()-start)/1000;
		cout <<endl<< "Czas trwania [ms] " << duration << endl;
		
	return 0;
} 

zmienne.h

#ifndef _ZMIENNE_H
#define _ZMIENNE_H
#include "funkcje.h"

	const int poziomtab = 47; // dotyczy tablicy poziomej
	const int piontab = 25; //dotyczy tablic pionowej

	const bool Linux=true; // dla windowsa wpisac false
	extern bool Testowanie; // zmien na false, jak nie chcesz widziec, gdzie sa statki
#endif 

funkcje.h

#ifndef _FUNKCJE_H
#define _FUNKCJE_H

#include <iostream> 
#include <iomanip> // setw()
#include <cstdlib> // srand()
#include <ctime> // time()
#include <time.h>

using namespace std;



class plansza;
class maszt;
class przeszkoda;

//*********************************************************************************************************************************************************

// ./fun/plansza.cpp

class plansza 
{
	public:
	  maszt  ***wsk;  // wskaznik do wskaznika na wskaznik :P
	  plansza();
	  ~plansza();
	  void wyswietl();
	  void zamien(int,int,int,int); // zmiana elemetów (x,y) na (x,y)
};

//*********************************************************************************************************************************************************

// ./fun/maszt.cpp

class maszt  // elementarna klasa
{
public:
  char stan;
  int typ; // 0 - przeszkoda, 3 - puste,
  maszt() : stan(' '), typ(3) {} // konstruktor, na poczatku nie ma zadnych stakow czyli maszty sa puste
  void wyswietl(); 
};

//*********************************************************************************************************************************************************


class przeszkoda
{
	public:
		maszt ***tablica;
		przeszkoda();
		~przeszkoda();
		void buduj(plansza &NazwaPlanszy);
		void ruch (plansza&,int);
		//bool CzyJest(int,int);
};


//*********************************************************************************************************************************************************

class jon
{
	public:
		int x,y;//wspolrzedne
		maszt *tab;
		jon();
		~jon();
		void buduj(plansza &NazwaPlanszy,przeszkoda&);
		void ruch(plansza&,przeszkoda&);
};

//*********************************************************************************************************************************************************

void czekaj( int sekundy );
bool CzyPuste(plansza&,int,int);
#endif 

maszt.cpp

#include "../lib/funkcje.h"
#include "../lib/zmienne.h"


void maszt::wyswietl()
{
    if(Testowanie)  // jak testujemy to pokazujemy statki od razu
		cout << stan << "  ";
	else  // jak gramy to statki sa ukryte
		(stan=='X') ? cout << ".  " : cout << stan << "  ";
} 

plansza.cpp

#include "../lib/funkcje.h"
#include "../lib/zmienne.h"



plansza::plansza()  // konstruktor planszy
{
  wsk=new maszt**[piontab+5];   // plansza jest 2-wymiarowa tablica wskaznikow do masztow
  for(int i=0; i<piontab+5; i++)  // rozmiar +5 a plansza zeby nie bylo przekroczenia zakresu przy losowym ustawianiu statkow 
  {							
      wsk[i]=new maszt*[poziomtab+5]; 
      for(int j=0; j<poziomtab+5; j++)
	  {
		  wsk[i][j]=new maszt();  // pojedynczy maszt
	  }
  }
}

plansza::~plansza()  // destruktor planszy, wykonuje sie kiedy plansza jest niszczona czyli po zakonczeniu gry
{
  for(int i=0; i<piontab+5; i++)   // zwolnienie zaalokowanej pamieci
  {
	  for(int j=0; j<poziomtab+5; j++)
	  {
		  delete wsk[i][j];  // niszczymy pojedyncze maszty
	  }
	  delete wsk[i];  // ... tablice masztow
  }
  delete wsk;   // ... i tablice tablic
  if(!Linux) system("pause");
}

void plansza::wyswietl() // wyswietlanie planszy
{
  if(Linux)system("clear");   // linux
  else system("cls"); // windows
  for(int i=1; i<=piontab; i++)  // wyswietlenie 16 wierszy
    {
	cout << setw(2) << i << " ";  // ladny rowny odstep
    for(int j=1; j<=poziomtab; j++)
		 wsk[i-1][j-1]->wyswietl(); // wyswietlanie 16 kolumn masztow
		cout << endl;

  }
  cout << "   ";//odpowiada za dolne liczby
	for (int j=1;j<=poziomtab;j++)
	{
		if(j<10)
			cout << j << "  ";
		else
			cout << j << " ";
	}
	cout << endl;
}


void plansza::zamien(int xw,int yw,int x, int y)
{
	maszt *prob = new maszt();
	prob = wsk[y][x];
	wsk[y][x]=wsk[yw][xw];
	wsk[yw][xw] = prob;
	delete prob;
}
	
	 

zmiany.cpp

#include "../lib/funkcje.h"
#include "../lib/zmienne.h"


void czekaj( int sekundy )// opcja czekania
{
    clock_t koniec_czekania;
    koniec_czekania = clock() + (sekundy * CLOCKS_PER_SEC)/50;
    while( clock() < koniec_czekania ) { }
} 

funbocz.cpp

 #include "../lib/funkcje.h"
#include "../lib/zmienne.h"

bool CzyPuste(plansza &NazwaPlanszy,int x,int y)
{
	return ( NazwaPlanszy.wsk[y][x]->typ!=1);
}
	

I nieszczęsne przeszkody.cpp

#include "../lib/funkcje.h"
#include "../lib/zmienne.h"



przeszkoda::przeszkoda()
{
  tablica=new maszt**[piontab+5];   // plansza jest 2-wymiarowa tablica wskaznikow do masztow
  for(int i=0; i<piontab+5; i++)  // rozmiar +5 a plansza zeby nie bylo przekroczenia zakresu przy losowym ustawianiu statkow 
  {							
      tablica[i]=new maszt*[poziomtab+5]; 
      for(int j=0; j<poziomtab+5; j++)
	  {
		  tablica[i][j]=new maszt();  // pojedynczy maszt
	  }
  }
}
przeszkoda::~przeszkoda()
{
	for(int i=0; i<piontab+5; i++)   // zwolnienie zaalokowanej pamieci
	  {
		  for(int j=0; j<poziomtab+5; j++)
		  {
			  delete tablica[i][j];  // niszczymy pojedyncze maszty
		  }
		  delete tablica[i];  // ... tablice masztow
	  }
	  delete tablica;   // ... i tablice tablic
	  if(!Linux) system("pause");
}


void przeszkoda::buduj(plansza &NazwaPlanszy)
{
	srand( time( NULL ) );
	for(int x=1;x<47;x=x+2)
	{
		int i=0;
		int ilosc = rand()%13 + 10;
		while( i < ilosc)
		{
			while(true)
			{
				int y=rand()%25;
				if (NazwaPlanszy.wsk[y][x]->typ==3)
				{
					NazwaPlanszy.wsk[y][x]->stan='X';
					NazwaPlanszy.wsk[y][x]->typ=0;
					tablica[y][x]=NazwaPlanszy.wsk[y][x];
					break;
				}
			}
			i++;
		}
	}
}
void przeszkoda::ruch(plansza &NazwaPlanszy,int i)
{
	/*for (int j=1;j<piontab;j++)
	{
		if(!CzyPuste(NazwaPlanszy,i,j))
		{
		  	int a;
			srand(time(NULL));
			a = rand()%2;
			if(a==1) // góra
			{
				if(CzyPuste(NazwaPlanszy,i,j+1)) // jeszcze nei zalozylem ze to moze byc maksymalna wartość planszy;
				{	
					NazwaPlanszy.zamien(i,j,i,j+1);
					j++;
				}
					
				else if(CzyPuste(NazwaPlanszy,i,j-1))
				{
					NazwaPlanszy.zamien(i,j,i,j-1);
					j--;
				}
				else 
					continue;
				
			}
			else 
			{
				if(CzyPuste(NazwaPlanszy,i,j-1))
				{
					NazwaPlanszy.zamien(i,j,i,j-1);	
					j--;
				}
				else if(CzyPuste(NazwaPlanszy,i,j+1)) // jeszcze nei zalozylem ze to moze byc maksymalna wartość planszy;
				{
					NazwaPlanszy.zamien(i,j,i,j+1);
					j++;
				}
				else 
					continue;
				
			}
		}
	}*/
	for (int j=0;j<piontab;j++)
	{
		if(j<24)
		{
			if(CzyPuste(NazwaPlanszy,i,j) && CzyPuste(NazwaPlanszy,i,j+1)) // rzn ze nie ma jonu tam
			{
				NazwaPlanszy.zamien(i,j,i,j+1);
				//j++;
			}
		}
		if(j==24)
		{
			if(CzyPuste(NazwaPlanszy,i,j) && CzyPuste(NazwaPlanszy,i,0))
				NazwaPlanszy.zamien(i,j,i,0);
		}
	}
}

//*********************************************************************************************************************************************************
//jony
jon::jon()
{
	tab = new maszt();
	tab->stan='j';
	tab->typ=1;
	x=0;
	//y=rand()%25;
	y=24;
}

jon::~jon()
{
	delete tab;
	if(!Linux) system("pause");
}
void jon::buduj(plansza &NazwaPlanszy, przeszkoda &NazwaPrzeszkody)
{
	NazwaPlanszy.wsk[y][x]=tab;
	NazwaPrzeszkody.tablica[y][x]=tab;
}

		                                        

Z góry dziękuję za pomoc,

Pozdrawiam,
Krystian

1

Wywal srand( time( NULL ) ); zewsząd oprócz pierwszego wiersza main.

0

Teraz rodzi się kolejne pytanie, na dole maina ten for powinien odpowiadać za wyświetlenie stanu danej "komórki") aczkolwiek z tego co widzę nie działa jak powinno.ponieważ wartości nie są takie jak powinny - dla x(przeszkoda), wartość 0, dla jonu wartość 1 dla pustego wartość 3, aczkolwiek takich nie wywala, co jest tego przyczyną ?

Btw, dlaczego ta funkcja srand może być wywołana tylko raz ?

Void przeszkoda zastąpiłem czymś takim

void przeszkoda::ruch(plansza &NazwaPlanszy,int i)
{
	for (int j=0;j<piontab;j++)
	{
		if(!CzyPuste(NazwaPlanszy,i,j))
		{
		  	int a;
			a = rand()%2;
			if(a==1) // góra
			{
				if(j<24 && CzyPuste(NazwaPlanszy,i,j+1)) // jeszcze nei zalozylem ze to moze byc maksymalna wartość planszy;
				{	
					NazwaPlanszy.zamien(i,j,i,j+1);
					j++;
				}
				else if(j==24 && CzyPuste(NazwaPlanszy,i,0))
						NazwaPlanszy.zamien(i,j,i,0);
					
				else if(j>0 && CzyPuste(NazwaPlanszy,i,j-1))
				{
					NazwaPlanszy.zamien(i,j,i,j-1);
					j--;
				}
				else if(j==0 && CzyPuste(NazwaPlanszy,i,piontab))
						NazwaPlanszy.zamien(i,j,i,piontab);
						
				else 
					continue;
				
			}
			else 
			{
				if(j>0 && CzyPuste(NazwaPlanszy,i,j-1))
				{
					NazwaPlanszy.zamien(i,j,i,j-1);
					j--;
				}
				else if(j==0 && CzyPuste(NazwaPlanszy,i,piontab))
						NazwaPlanszy.zamien(i,j,i,piontab);
					
				else if(j<24 && CzyPuste(NazwaPlanszy,i,j+1)) // jeszcze nei zalozylem ze to moze byc maksymalna wartość planszy;
				{	
					NazwaPlanszy.zamien(i,j,i,j+1);
					j++;
				}
				else if(j==24 && CzyPuste(NazwaPlanszy,i,0))
						NazwaPlanszy.zamien(i,j,i,0);
				else 
					continue;
				
			}
		}
	}/*

a Czy puste

bool CzyPuste(plansza &NazwaPlanszy,int x,int y)
{
	return ( NazwaPlanszy.wsk[y][x]->typ==3 && NazwaPlanszy.wsk[y][x]->typ!=1);
} 
1

return ( NazwaPlanszy.wsk[y][x]->typ!=3 && NazwaPlanszy.wsk[y][x]->typ!=1);
aczkolwiek ja bym dał: return ! NazwaPlanszy.wsk[y][x]->typ;

0

Jak tak zmieniłem to masakra :P Przeszkody znikają, a na dole wszędzie 1dynki :)

0

Ok, dzięki za uwagę, aczkolwiek dalej problem pozostaje nierozwiązany :(

1 użytkowników online, w tym zalogowanych: 0, gości: 1