Karel vol2. – C / C++ – Fórum – Programujte.com

Zdravicko znovu... tak mam opet dotaz ke karlovi cihly uz se mi vykreslujou a da se po nich "slapat" aby nezmizeli :D

ale mam jeden problem ted jsem na to nemel dost casu tak jsem se tomu moc nevenoval pokazde kdyz polozim novou cihlu tak se mi putne ta stara vlastne se jakoby prepisou souradnice 

        else if(!strcmp("poloz",prikaz))
        {
            pole_x[250] = gotoxy_postava_left;
            pole_y[250] = gotoxy_postava_top;
        }

zde jak vidite mam spatne napsane ukladani do pole ... a tim se dostavame k me otazce ... jak ulozim moje souradnice do pole? zkousel jsem uz strasne moc moznosti :D a uz fakt nevim jak dal v kodu je pole_x[250] tudiz pole souradnic X a pole Y a ja potrebuju aby vzdy kdyz !strcmp("poloz")  tak aby se mi souradnice alias gotoxy_postava top a left zapsali do tech poli ale takhle se mi prepisou vzdy ... poradil by jste mi stim nekdo? pro vas je to urcite banalni vec :) predem dekuju pekne

nevim jestli rozumim, ale asi takto:

- udelat dvourozmerne pole treba booleanu (true = cihla je polozena, false znamena, ze neni)

- pak ukladat do pole po polozeni cihly:

pole[y_souradnice_karla][x_souradnice_karla] = true;

Ale mozna jen nechapu dotaz...

jeste jednou aby jsme si rozumeli potrebuji udelat pole do ktereho se mi budou ukladat souradnice takze na zacatku by bylo dejme tomu int pole_x[250],pole_y[250]; a kdyz dam prikaz poloz aby se mi do toho pole napsali souradnice takze aby pole vypadalo potom takhle pole_x[250] = { 10 }; pole_y[250] = {17} protoze jsem byl na souradnicich x = 10; a y = 17; kdyz jsem dal prikaz poloz a pokazde kdyz dam poloz aby se to tam zapisovalo treba aby to po 2 prikazech vypadalo takto pole_x[250] = {10,31}; pole_y[250] = { 20, 33} a kdyz budu chtit vykreslovat cihli tak napisu jen for cyklus a pote gotoxy(POLE_X,POLE_Y); uz si rozumime? proste potrebuju porad zapisovat do pole souradnice neco jako davat naboje do zasobniku :)

vhodnější je jak radí Tom: dvourozměrné pole kde jeden index je x a druhý y souřadnice. 

int pole[50] [50];

//cele pole musis zinicializovat na 0 = není polozena cihla

if(!strcmp("poloz",prikaz))

{

pole[x] [y] = 1;    //1 znamena polozenou cihlu

}

můžeš to zdokonalit a číslo při položení inkrementovat a tak skládat cihly na sebe

hu

... přičemž velikost toho pole je stejná jako velikost hracího plánu

hu

Asi budeš brzy řešit příkaz vezmi: v řešení od Toma je to snadné, na příkaz vezmi uděláš

pole[x] [y] = 0;

hu

#6 hlucheucho
fajn tohle chapu ale stale nechapu kam se zapisujou ty souradnice? ^^ v tom co si napsal neni zapis souradic do pole

protoze takhle kdyz to napisu tak jsem tam kde jsem byl xD akorad to funguje na princip dvou rozmerneho pole ja potrebuju aby po prikazu "poloz" se ukladali do pole souradnice a ty bych pak mohl vyvolavat pomoci cyklu a vsechny putnute cihly vykreslit tohle co jsi napsal je akorad jina verze toho co uz mam takze kdyz dam poloz tak to vykresli cihlu ale kdyz dam po druhe poloz tak to vykresli stejnou cihlu akorad na jine souradnice a tu prvni to smaze

ale vymaze je to protoze tam mam system("cls"); hm :D zkusim to bez toho to by melo jit a pak pouziju ncsources 

#9 Atheo
jo ano ted jsem to zkusil takze pokud to udelam tak jak ty pises bez cls tak se vykreslej oba dva...pokud dam 2x poloz ale kdyz pres obe cihly prejedu tak to tu druhou nedeletne protoze se vykresli znovu ale tu prvni co byla uz vykreslena to smaze protoze kdyz pres ni prejedu tak se na ni putne znak karla a uz se nevykresli

souřadnice ukládat nemusím. Každý prvek z pole[x] [y] představuje jedno pole hracího plánu a obsahuje informaci o tom, zda na tomto místě leží cihla.  Položit cihlu na souřadnice (9, 43) znamená udělat (souřadnice použiji jako indexy pole)
 

pole[9] [43] = true;

pro cihly na hromádku
 

pole[9] [43]++;

při vykreslování pak toto pole projedu prvek po prvku:
 

int i,j;

for (i = 0; i < 50; i++)  {
  for (j = 0; j < 50; j++)  {
    if (pole)  {
      //vykresli cihlu (nebo cihly)
    }
    else  {
      //prazdne pole bez cihel
    }
  }
}

v příkladech předpokládám herní plán 50 x 50 polí

hu

vloudil se překlep :(
 

if(pole[i] [j])  {

tam mělo být

asi chceš evidovat souřadnice kam si položil cihlu. Má to více nevýhod než výhod. Jednak více paměti:
Do hracího plánu 50x50 můžeš položit až 2500 cihel (max jedna na jednom poli). Každé pole má 2 souřadnice, což by znamenalo, že bys musel uložit až 5000 souřadnic (= int hodnot), kromě toho evidovat počet položených cihel. K tomu přibude komplikovaná režie při "vezmi" libovolnou cihlu. 

Dalo by se to řešit pomocí vektoru ze STL, každá položená cihla by byla struktura obsahující svoje souřadnice a ty by se skládaly do vektoru.... Je to jako jít se samopalem na komára

hu

#13 hlucheucho
ja uz jsi fakt pripadam jako debil :D mrkni se mi prosim na to co tam mam spatne ted kdyz to zkompiluju tak mi to vyplaca 3 cihly hned od sebe a podobne... viz obrazky

#include <stdio.h>
#include "funkce.h"

char prikaz[0];
int gotoxy_postava_left = 5,gotoxy_postava_top = 5,karel = 16;
int pole[10][40];
int main(i,j)
{
    for(;;)
    {
        for (i = 0; i < 40; i++)  {
            for (j = 0; j < 40; j++)  {
                if (pole[i][j])  {
                    barva(1);
                    putc(219,stdout);
      }
                else  {
                    barva(-1);
                    putc(219,stdout);
                      }
                                      }
                                  }


    barva(2);
    gotoxy(gotoxy_postava_left,gotoxy_postava_top);
    putc(karel,stdout);

    barva(1);
    gotoxy(1,1);
    printf("zadej prikaz: ");
    scanf("%s", &prikaz);

    if(!strcmp("krok",prikaz))
    {
        gotoxy_postava_left += 1;
        gotoxy(gotoxy_postava_left-1,gotoxy_postava_top);
        barva(-1);
        putc(219,stdout);
    }
    else if(!strcmp("poloz",prikaz))
    {
        pole[gotoxy_postava_left][gotoxy_postava_top]++;
    }
    }
    return 0;
}

karel = 16; //  to je znak ► gotoxy_postava_top a left to jsou souradnice kde se karel vykresli

obrazek1 = http://jpeg.cz/images/2012/08/02/apeK0.png // kdyz nic neudelam

obrazek2 = http://jpeg.cz/images/2012/08/02/mdWR4.png // kdyz dam krok :D

hned po spuštění si to pole musíš nastavit tak, že nejsou žádný cihly:
 

int pole[10][40];
int i, j;

for (i = 0; i < 10; i++)  {
  for (j = 0; j < 40; j++ {
    pole[i] [j] = 0;
  }
}

Pak vykreslíš Karla do zákl. pozice a spustíš hlavní smyčku programu

hu

Ještě poznámku:
Co použít debugger? Krokovat nebo zastavit na breakpointu, podívat se, co je v proměnných....

hu

#15 hlucheucho
nyni to mam takto :

 

int pole[9][43];

int i,j;
for(i = 0; i < 9; i++)  {
        for(j = 0; j < 43; j++) {
            pole[i][j] = 0;
  }
}

for(;;)
    {
        for (i = 0; i < 9; i++)  {
            for (j = 0; j < 43; j++)  {
                if (pole[i][j])  {
                    barva(1);
                    putc(219,stdout);
    }
    else  {

      pole[i][j] = 0;
    }
  }
}
/* do ted je to myslim spravne... ale kdyz dam poloz tak mi to vykresli cihlu misto na misto kde je karel tak na nejakou souradnici X= 1 a Y =1 a pokud dam zase poloz tak se to putne na X=2,Y=1 a takhle*/

// podminku pro poloz mam takto tam bude nekde failik

    else if(!strcmp("poloz",prikaz))
    {
        pole[gotoxy_postava_left][gotoxy_postava_top]++;
    }

#16 hlucheucho
zkus mi sem prosim napsat ten kod celeho toho pole,vykresleni pole 0 a pak vykresleni pole po zadani prikazu :D ja vim ze uz te to nebavi protoze jsem nejspis idiot ale delam vse co mi rikas a chapu te jak to myslis :D ale proste mi to nefunguje a nevim proc to me na tom stve nejvic:D

Shrneme si to:

mám pole, které představuje hrací plán. Každý prvek pole představuje jedno hrací políčko herního plánu. Na políčko lze vstoupit, položit na něj cihlu (další činnosti zatím vynecháme). Dále mám proměnné x a y, které obsahují polohu Karla.
 

int pole[10] [10];   //hraci plan 10x10 policek
int x, y;            //pozice Karla
int i, j;            //pomocne promenne

Algoritmus je snadný. Nejdříve inicializuji proměnné:
- vynuluji pole, před započetím práce nikde neleží cihla
- nastavím počáteční pozici Karla

V hlavní smyčce provedu:
- vykreslím hrací pole vč. cihel (projedu pole prvek po prvku)
- vykreslím Karla na jeho pozici (pozice je x, y)
- čekám na příkaz
- po přijetí příkazu dekoduji příkaz:
   - krok  inkrementuji nebo dekrementuji x nebo y podle směru pohybu
   - polož  zapíšu do pole položenou cihlu na pozici x,y   (pole[x] [y]  = true)

#20 hlucheucho
no takhle kdyz to pises teoreticky tak jsem stale v obraze :D pokracuj uvidime kdy se ztratim:D

Při pohybu Karla nesmíš zapomenout na to, že se smí pohybovat jen po hracím plánu. V programu to znamená ošetřit meze polí. Pole se v C indexují od 0. Takže v našem příkladu s herním plánem 10x10 políček máme souřadnice od 0 do 9 včetně. Pohyb Karla ošetříš tak aby vždy platily podmínky:

x  >= 0
x <= 9
y >= 0
y <= 9

hu

#22 hlucheucho
tim nejspis myslis udelat steny naseho pole alias zdi ze karel != 0 a !=10 tzn teoreticky pokud se karel rovna 10 vrati to karla zpet o jedno policko

a podobně pro polohu Karla = -1, poloha 0 je přípustná

hu

inicializace:
 

x = 0;        //Karel zacne z polohy 0,0
y = 0;
smer = VPRAVO; //pujde defaultne vpravo pokud mu neprikazes jinak
for (i = 0; i < 10; i++) {
  for (j = 0; j < 10; j++) {
    pole[i] [j] = 0;
  }
}

a funkce, co by udělala krok by mohla vypadat třeba takto:
 

//smery pohybu:
#define VPRAVO   0
#define VLEVO    1
#define HORE     2
#define DOLE     3

int krok()
{
	switch (smer) {
	  case VPRAVO:
		if (x < 9) {
		  x++;
		  return smer;
		}
		break;

	  case VLEVO:
		if (x > 0) {
		  x--;
		  return smer;
		}
		break;

	  case HORE:
		if (y < 9) {
		  y++;
		  return smer;
		}
		break;

	  case DOLE:
		if (y > 0) {
		  y--;
		  return smer;
		}
		break;
	}
	return -1;             //je u zdi, nelze udelat krok
}

hu

#25 hlucheucho
udelal jsem to takto neberme ted v potaz smery ani ohraniceni  

#include <stdio.h>
#include "funkce.h"

int x = 5,y = 5;  /* souradnice karla */
int i,j; /* promenne cyklu */
int karel = 16; /* znak karla */
char prikazy[0]; /* promenna prikazy */

int main()
{
    for(;;)
    {
        barva(2);
        gotoxy(x,y);
        putc(karel,stdout); // vykresli karla na ose X Y tudiz 5,5

        barva(1);
        gotoxy(1,1);
        printf("zadej prikaz: ");
        scanf("%s", &prikazy);

        if(!strcmp("krok", prikazy)) /* pokud se zadany prikaz bude = krok tak karel udeka krok v pred tedy X +1 -> a smaze se znak za nim */
        {
            x +=1 ;
            gotoxy(x-1,y);
            barva(-1);
            putc(219,stdout);
        }
    }
return 0;
}

a ted potrebuju dostat do tohodle kodu to o co mi vlastne jde zapis cihel do pole

 Nechces nieco taketo? :

//zatial je obrazovka prazdna

for (i = 0; i < 10; i++)
  for (j = 0; j < 10; j++)
	  if(pole[i] [j] != 0){
 		gotoxy(i, j);
		putc(STENA, stdin);
	  }
gotoxy(x,y);
putc(KAREL,stdout);

Ak sa budes chciet posunut tak staci prekreslit povodnu poziciu a novu poziciu

#25 hlucheucho
 

#include <stdio.h>
#include "funkce.h"

int x = 5,y = 5;  /* souradnice karla */
int i,j; /* promenne cyklu */
int karel = 16;
char prikazy[0];
int pole[10][10];


int main()
{

    for (i = 0; i < 10; i++) {
        for (j = 0; j < 10; j++) {
            pole[i][j] = 0;
                                 }
                             }


    for(;;)
    {
        
        for (i = 0; i < 50; i++)  {
            for (j = 0; j < 50; j++)  {
                if (pole)  {
                    barva(2);
                    putc(219,stdout);
                            }
                else  {
                    pole[i][j] = 0;
    }
  }
}
        
        
        barva(2);
        gotoxy(x,y);
        putc(karel,stdout);

        barva(1);
        gotoxy(1,1);
        printf("zadej prikaz: ");
        scanf("%s", &prikazy);

        if(!strcmp("krok", prikazy))
        {
            x +=1 ;
            gotoxy(x-1,y);
            barva(-1);
            putc(219,stdout);
        }
        else if(!strcmp("poloz", prikazy))
        {
         /* zde je treba to co nevim :D */
        }
    }
return 0;
}

a takto vypada kod po vykresleni prazdneho pole akorad ted prave nevim ( predpokladam ze to ted to mam spravne ) ... tak nevim jak to presne napsat do prikazu poloz  

else if(!strcmp("poloz", prikazy))
        {
         /* zde je treba to co nevim :D */
        }

#27 vitamin
nene nejspis jsi to necetl cele mam problem s ukladanim X,Y do  pole a postupne vykreslovani cihel

myslel jsem to takhle (jen kostra):
 

//smery pohybu:
#define VPRAVO   0
#define VLEVO    1
#define HORE     2
#define DOLE     3

int pole[10] [10];   //hraci plan 10x10 policek
int x, y;            //pozice Karla
int i, j;            //pomocne promenne

int smer;

int krok()
{
	switch (smer) {
	  case VPRAVO:
		if (x < 9) {
		  x++;
		  return smer;
		}
		break;

	  case VLEVO:
		if (x > 0) {
		  x--;
		  return smer;
		}
		break;

	  case HORE:
		if (y < 9) {
		  y++;
		  return smer;
		}
		break;

	  case DOLE:
		if (y > 0) {
		  y--;
		  return smer;
		}
		break;
	}
	return -1;             //je u zdi, nelze udelat krok
}



int _tmain(int argc, _TCHAR* argv[])
{

//inicializace:
x = 0;        //Karel zacne z polohy 0,0
y = 0;
smer = VPRAVO; //pujde defaultne vpravo pokud mu neprikazes jinak
for (i = 0; i < 10; i++) {
  for (j = 0; j < 10; j++) {
    pole[i] [j] = 0;
  }
}

//hlavni smycka
while (1)
  {
	//vykreslim cihly
	for (i = 0; i < 10; i++) {
	  for (j = 0; j < 10; j++) {
	    gotoxy(i, j);
		if (pole[i] [j]) {
		  //kresli cihlu
		}
		else  {
		  //kresli prazdne policko
        }
	  }
	}
	//vykreslim Karla
	gotoxy(x, y);
	barva(2);
	putc(karel,stdout);
	//cekam na prikaz
	//sem das cekani na prikaz
	//pak dekodovani, napr.
	if(!strcmp("krok", prikazy))
	{
		if (krok == -1) {
          //je tam zed, nelze udelat krok
		}
    }
  }
	return 0;
}

hu

Ty moje překlepy: krok je funkce, chybí závorky 

if(!strcmp("krok", prikazy))
{
  if(krok() == -1)
  {
    //nelze udelat krok
  }
}

sorry

hu

#31 hlucheucho
ano takhle to mam  akorad na jiny princip ale funguje to stejne ale nevim co presne napsat do 

else if(!strcmp("poloz", prikazy))
        {
         /* zde je treba to co nevim :D */
        }
/* myslel jsem pole[x][y] = 1; ale to mi nefungovalo */

    for(;;)
    {
        
        for (i = 0; i < 50; i++)  {
            for (j = 0; j < 50; j++)  {
                if (pole)  {  //zde porovnáváš hodnotu pointeru, zřejmě bude vyhodnoceno jako true
                    barva(2);
                    putc(219,stdout);
                            }
                else  {  
                    pole[i][j] = 0;   //a zde bys prepisoval informaci o umisteni cihel
    }
  }
}

správně by mělo být
 

    for(;;)
    {
        
        for (i = 0; i < 50; i++)  {
            for (j = 0; j < 50; j++)  {
                if (pole[i] [j])  {
                    barva(2);
                    putc(219,stdout);
                            }
                else  {
                    barva(?);  //nevim cislo pro barvu prazdneho policka
                    putc(?, stdout);  //nevim znak pro prazdne policko
    }
  }
}

hu

#33 hlucheucho
ted to mam takto 

int main()
{

    for (i = 0; i < 10; i++) {
        for (j = 0; j < 10; j++) {
            pole[i][j] = 0;
                                 }
                             }


    for(;;)
    {

        for (i = 0; i < 10; i++)  {
            for (j = 0; j < 10; j++)  {
                if (pole[i][j])  {
                    barva(2);
                    putc(219,stdout);
                            }
                else  {
                    barva(-1);
                    putc(219,stdout);
    }
  }
}


        barva(2);
        gotoxy(x,y);
        putc(karel,stdout);

        barva(1);
        gotoxy(1,1);
        printf("zadej prikaz: ");
        scanf("%s", &prikazy);

        if(!strcmp("krok", prikazy))
        {
            x +=1 ;
            gotoxy(x-1,y);
            barva(-1);
            putc(219,stdout);
        }
        else if(!strcmp("poloz", prikazy))
        {
            pole[x][y]= 1;
        }
    }
return 0;
}

ale kdyz dam poloz tak mi to vykresluje cihly na nesmyslne mista a ne na misto kde je karel

prvni "poloz" to putne znak na gotoxy x = 0, y = 2; kdyz udelam krok a dam zase "poloz" vykresli to cihlu na X = +- 9, a Y = 2; ja uz nevim co tam mam spatne :D fakt uz nevim:D

ten printf ti píše dovnitř hracího plánu. Chtělo by to psát pod něj. Druhá věc je velikost hracího pole. Do začátku bych zkusil 10x10. Pokud použiješ u funkce gotoxy(x, y)  větší souřadnici než má použité zobrazovací zařízení, hodnotu bude ignorovat a místo ní použije 0 (aspoň tak jsem pochopil nápovědu)

hu

Ma to fungovat takto?

//hodnoty si nastav sam
const int KAREL = '@';
const int TEHLA = '#';
const int NIC   = ' ';
const int POLICKO[] = {NIC, TEHLA};

#define ROZMER 10
//mas sachovnicu urcitych rozmerov, napr 10x10 policok:
bool pole[ROZMER][ROZMER];	//kazde policko uchovava hodnotu ci tam je stena alebo nie (0=prazdne policko, 1=stena)
unsigned 	karel_x=5, karel_y=5;    //pozicia karla je ulozena mimo sachovnicu
	
enum ePosun{HORE, DOLE, VLAVO, VPRAVO};
bool PosunKarla(ePosun posun){
	//zmaze karla: (prekresli ho tehlou alebo prazdnou hodnotou)
	gotoxy(karel_x, karel_y);
	putc(POLICKO[pole[karel_x][karel_y]], stdout);
	
	//posunie karla
	switch(posun){
		case HORE:
			if(karel_y == 0)return false;
			--karel_y;
			break;
		case DOLE:
			if(karel_y == ROZMER-1)return false;
			++karel_y;
			break;
		case VLAVO:
			if(karel_x == 0)return false;
			--karel_x;
			break;
		case VPRAVO:
			if(karel_x == ROZMER-1)return false;
			++karel_x;
			break;
		}
		
	//vykresli karla:
	gotoxy(karel_x, karel_y);
	putc(KAREL, stdout);
		
	return true;
}
//polozis tehlu pod karla, ale tehla sa zobrazi az ked sa karol posunie
void PolozTehlu(){
	pole[karel_x][karel_y] = 1;
}
int main(){
	
	//vynulujes vsetky steny na sachovnici:
	for (int i = 0; i < 10; i++)
        for (int j = 0; j < 10; j++)
            pole[i][j] = 0;
            
	
    PosunKarla(DOLE);		//netestujem ci sa podaril posun karla
    PolozTehlu();
    PosunKarla(DOLE);
    PolozTehlu();
    PosunKarla(VLAVO);
    PosunKarla(HORE);
                                 
                             
    return EXIT_SUCCESS;
}

Když mi dáš funkci barva(..), u které odhaduji prototyp
 

void barva(int color);

tak bych si to tu mohl zkusit v debuggeru nakrokovat

hu

#36 vitamin
jj, to jsem myslel. Když pak pole uděláš int, tak PolozTehlu(); může skládat komínky, akorát se musí uzpůsobit grafika. Pamatuju si, že Karel na PMD85 to před 25 lety uměl, dělal z vodorovných čárek komínky :)

hu

/*****************************************************************************/
/********************************Funkce.h*************************************/
/*****************************************************************************/
#include <stdio.h>
#include <math.h>
#include <stdlib.h>
#include <windows.h>


void vymaz();
void gotoxy(int, int);
void barva(int);
int MyGetch (void);


/* Vycisti obraz */
void vymaz()
{
	COORD coordScreen = { 0, 0 };
	DWORD cCharsWritten;
	CONSOLE_SCREEN_BUFFER_INFO csbi;
	DWORD dwConSize;
	HANDLE hConsole = GetStdHandle(STD_OUTPUT_HANDLE);

	GetConsoleScreenBufferInfo(hConsole, &csbi);
	dwConSize = csbi.dwSize.X * csbi.dwSize.Y;
	FillConsoleOutputCharacter(hConsole, TEXT(' '), dwConSize, coordScreen, &cCharsWritten);
	GetConsoleScreenBufferInfo(hConsole, &csbi);
	FillConsoleOutputAttribute(hConsole, csbi.wAttributes, dwConSize, coordScreen, &cCharsWritten);
	SetConsoleCursorPosition(hConsole, coordScreen);
}

/* Funkce GotoXY pro souradnice */
void gotoxy(int x, int y)
{
	COORD point;
	point.X = x; point.Y = y;
	SetConsoleCursorPosition(GetStdHandle(STD_OUTPUT_HANDLE), point);
}
/* Funkce MyGetch pro pouziti sipkovych klaves */
int MyGetch (void)
{
  int Ret = getch();
  if ((!Ret || Ret == 0xE0) && kbhit())
    Ret = 256 + getch();
  return Ret;
}

/* Funkce barev */
void barva(int color)
{
	switch (color)
	{
    case -3:	/* Zluta na Sedem */
		SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),FOREGROUND_INTENSITY |
			BACKGROUND_INTENSITY | FOREGROUND_RED | FOREGROUND_GREEN);
		break;
    case -2:	/* Seda na Sedem */
		SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),FOREGROUND_INTENSITY |
            BACKGROUND_INTENSITY);
		break;
    case -1:	/* Cerna na Cernem */
		SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),0);
		break;
	case 0:	/* Bila na Cerne */
		SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),FOREGROUND_INTENSITY |
			FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
		break;
	case 1:	/* Cervena na Cerne */
		SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),FOREGROUND_INTENSITY |
			FOREGROUND_RED);
		break;
	case 2:	/* Zelena na Cerne */
		SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),FOREGROUND_INTENSITY |
			FOREGROUND_GREEN);
		break;
	case 3:	/* Zluta na Cerne */
		SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),FOREGROUND_INTENSITY |
			FOREGROUND_RED | FOREGROUND_GREEN);
		break;
	case 4:	/* Modra na Cerne */
		SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),FOREGROUND_INTENSITY |
			FOREGROUND_BLUE);
		break;
	case 5:	/* Purpurova na Cerne */
		SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),FOREGROUND_INTENSITY |
			FOREGROUND_RED | FOREGROUND_BLUE);
		break;
	case 6:	/* Azurova na Cerne */
		SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),FOREGROUND_INTENSITY |
			FOREGROUND_GREEN | FOREGROUND_BLUE);
		break;
	case 7:	/* Cerna na Sede */
		SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),BACKGROUND_INTENSITY |
			BACKGROUND_INTENSITY);
		break;
	case 8:	/* Cerna na Bile */
		SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),BACKGROUND_INTENSITY |
			FOREGROUND_INTENSITY | BACKGROUND_RED | BACKGROUND_GREEN | BACKGROUND_BLUE);
		break;
	case 9:	/* Cervena na Bile */
		SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),BACKGROUND_INTENSITY |
			FOREGROUND_INTENSITY | BACKGROUND_RED | BACKGROUND_GREEN | BACKGROUND_BLUE |
			FOREGROUND_RED);
		break;
	case 10: /* Zelena na Bile */
		SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),BACKGROUND_INTENSITY |
			FOREGROUND_INTENSITY | BACKGROUND_RED | BACKGROUND_GREEN | BACKGROUND_BLUE |
			FOREGROUND_GREEN);
		break;
	case 11: /* Zluta na Bile */
		SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),BACKGROUND_INTENSITY |
			FOREGROUND_INTENSITY | BACKGROUND_RED | BACKGROUND_GREEN | BACKGROUND_BLUE |
			FOREGROUND_RED | FOREGROUND_GREEN);
		break;
	case 12: /* Modra na Bile */
		SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),BACKGROUND_INTENSITY |
			FOREGROUND_INTENSITY | BACKGROUND_RED | BACKGROUND_GREEN | BACKGROUND_BLUE |
			FOREGROUND_BLUE);
		break;
	case 13: /* Purpurova na Bile */
		SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),BACKGROUND_INTENSITY |
			FOREGROUND_INTENSITY | BACKGROUND_RED | BACKGROUND_GREEN | BACKGROUND_BLUE |
			FOREGROUND_RED | FOREGROUND_BLUE);
		break;
	case 14: /* Azurova na Bile */
		SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),BACKGROUND_INTENSITY |
			FOREGROUND_INTENSITY | BACKGROUND_RED | BACKGROUND_GREEN | BACKGROUND_BLUE |
			FOREGROUND_GREEN | FOREGROUND_BLUE);
		break;
	case 15: /* Bila na Bile */
		SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),BACKGROUND_INTENSITY |
			FOREGROUND_INTENSITY | BACKGROUND_RED | BACKGROUND_GREEN | BACKGROUND_BLUE |
			FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
		break;
	default : /* Bila na Cerne */
		SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),FOREGROUND_INTENSITY |
			FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
		break;
	}
}
/*****************************************************************************/
/********************************Konec****************************************/
/*****************************************************************************/

tady prikladam cely soubor funkce.h

btw : porad se tu bavime jen o tom jak to vykreslit ja taky potrebuju vedet co mam napsat "kdyz prikaz bude poloz" bla bla

a zde prikladam main.c ktery mam na test toho putu cihel  

#include <stdio.h>
#include "funkce.h"

int x = 0,y = 0;  /* souradnice karla */
int i,j; /* promenne cyklu */
int karel = 16;
char prikazy[0];
int pole[10][10];


int main()
{

    for (i = 0; i < 10; i++) {
        for (j = 0; j < 10; j++) {
            pole[i][j] = 0;
                                 }
                             }


    for(;;)
    {

        for (i = 0; i < 10; i++)  {
            for (j = 0; j < 10; j++)  {
                if (pole[i][j])  {
                    barva(2);
                    putc(219,stdout);
                            }
                else  {
                    barva(-1);
                    putc(219,stdout);
    }
  }
}


        barva(2);
        gotoxy(x,y);
        putc(karel,stdout);

        barva(1);
        gotoxy(1,1);
        printf("zadej prikaz: ");
        scanf("%s", &prikazy);

        if(!strcmp("krok", prikazy))
        {
            x +=1 ;
            gotoxy(x-1,y);
            barva(-1);
            putc(219,stdout);
        }
        else if(!strcmp("poloz", prikazy))
        {
            pole[x][y]= 1;
        }
    }
return 0;
}

zkus mi to prosim upravit tak aby to fungovalo myslim ze uz do toho chybi jen malicko jen nevim co a kdyz to napisu tak ty se bavis o5 o vykreslovani a ne o tom kde mam chybu:D

Teď jsem si všiml ještě jedné věci:
 

char prikazy[0];

to pole by mělo mít nenulovou velikost
 

char prikazy [32];  //řetězec max 31 znaků

hu

#40 hlucheucho
i s nulovou velikosti to funguje tak , jak ma i kdyz mas pravdu ze by nemelo

#42 hlucheucho
super funguje to detaily uz si dolatim :) moc diky

#42 hlucheucho
Jeste se chci zeptat da se udelat aby pole zacinalo az od souradnic X = 1 , Y = 1? aby to nezacinalo od nulove hodnoty?.. jestli se vlastne s tim polem da hejbat ^^ 

#44 Atheo
uz to vim ;)

#44 Atheo

celé pole při vykreslování můžeš posunout kamkoliv na monitor. Pokud to posuneš o (xOffset, yOffset), pak stačí přičíst offset k souřednicím vykreslovaného znaku(x, y).
 

gotoxy(x+xOffset, y+yOffset);
putc(cosi, stdout);

hu

#46 hlucheucho
ja jsem to vyresil tak ze do cyklu vykreslovani jsem akorad dal I = 1 J = 1 misto nolovych hodnot

tím se zmenší hrací plán na 9x9 a k tomu je kus nevyužitého pole, navíc se musí změnit meze pohybu. Pokud bys to pak měl posunout např vodorovně na střed, pak by tvoje řešení nefungovalo vůbec. S offsetem lze umístit hrací plán kdekoliv na ploše monitoru.

hu

Podobně fungují Windows formuláře. Vše, co je v nich umístěno má své souřadnice vztažené k hornímu levému rohu formuláře bez ohledu na to, kde se formulář na monitoru nachází. Poloha je pojem relativní.....

hu