game maker
Gebruikersnaam:
Wachtwoord:
Home Info Forums Help
Welkom, Gast. Alsjeblieft inloggen of registreren.
+  Forums
|-+  Werken met Game Maker
| |-+  Tutorials en Uitbreidingen (Moderator: Maarten Baert)
| | |-+  [Tut] Grids (datastructuur)
Pagina's: [1] 2
« vorige volgende »
Print
Advertenties

Flumble
Gebruiker


Offline Offline

Berichten: 2020


« Gepost op: 28 April 2008, 21:04:42 »

Versies: 5.x of hoger (een aantal functies is nieuw in GM7)
Niveau: Gevorderden (Basiskennis van GML vereist)
Registratie vereist: Ja

Inhoud

In deze tutorial zal ik jullie wegwijs maken in het gebruik van grids (rasters). Met grids kan je makkelijk en snel eigenschappen van een terrein opslaan, instanties en objecten rangschikken, matrices maken en nog talloze andere dingen. Deze tutorial is opgedeeld in de volgende hoofdstukken:

  • Hoofdstuk 1: De basisfuncties van een grid
  • Hoofdstuk 2: Werken met regio's
  • Hoofdstuk 2.1: Rechthoekige regio's
  • Hoofdstuk 2.2: Ronde regio's
  • Hoofdstuk 3: De laatste functies
  • Updates

De Basisfuncties

Allereerst zal ik vertellen hoe een grid in elkaar zit. Een grid is namelijk een soort raster waarin je in elk hokje een variabele kan zetten. Als je al eens met 2-dimensionale arrays hebt gewerkt, snap je waarschijnlijk al hoe dit werkt. Alleen zit het grote verschil tussen arrays en grids in de snelheid en de functies - grids werken sneller (met bijna elke functie) en je hebt meer functies.
Elk hokje heeft een x- en y-positie waaraan je hem kan herkennen. Denk maar aan een schaakbord, waarop bijvoorbeeld een toren op plaats 5B staat.
In het hokje (4,1) (<-de B is de tweede letter van het alfabet en we beginnen in GM altijd met de coördinaat (0,0) ) staat dan de waarde "Toren". (In deze tutorial gebruik ik een schaakbord als voorbeeld)

Als je een beetje snapt hoe een grid in elkaar zit, gaan we beginnen met onze eerste functie:
GML:
ds_grid_create(breedte, hoogte);
Hiermee maak je een grid aan. Met breedte en hoogte geef je aan hoeveel bij hoeveel hokjes de grid moet zijn. Deze functie geeft ook een waarde terug: het identificatienummer. Deze heb je nodig voor alle andere grid-functies, dus weet zeker dat je hem opslaat! (Dit kan in een variabele of andere datastructuur.)

Het is ook belangrijk om de grid weer te verwijderen wanneer je hem niet meer nodig hebt - grids nemen redelijk veel werkgeheugen in beslag. Om je grid te verwijderen, gebruik je de functie:
GML:
ds_grid_destroy(nummer);
nummer is het identificatienummer dat je hebt gekregen bij het maken van de grid (dat je hopelijk wél hebt opgeslagen in een variabele).

Nu wil je zeker heel graag iets nuttigs doen met je grid? Nou, vooruit, we lopen even op de zaken (GM-handleiding) vooruit en gaan waarden wegschrijven naar de grid. Dit doe je met de functie:
GML:
ds_grid_set(nummer, X, Y, waarde);
Hiermee zet je de waarde waarde in de grid nummer op positie (X,Y). Bedenk wel dat de positie binnen de grid moet liggen, anders wordt de waarde niet opgeslagen. De posities waar je een waarde kan opslaan, gaan van (0,0) tot (breedte,hoogte).
Nu kunnen we beginnen met het invullen van het schaakbord:
GML:
var xx,yy;
//Een schaakbord is veelal 8 bij 8 hokjes:
sb = ds_grid_create(8, 8);
ds_grid_set(sb, 0, 0, "TorenWit"   ); ds_grid_set(sb, 0, 7, "TorenZwart"   );
ds_grid_set(sb, 1, 0, "PaardWit"   ); ds_grid_set(sb, 1, 7, "PaardZwart"   );
ds_grid_set(sb, 2, 0, "LoperWit"   ); ds_grid_set(sb, 2, 7, "LoperZwart"   );
ds_grid_set(sb, 3, 0, "KoninginWit"); ds_grid_set(sb, 3, 7, "KoninginZwart");
ds_grid_set(sb, 4, 0, "KoningWit"  ); ds_grid_set(sb, 4, 7, "KoningZwart"  );
ds_grid_set(sb, 5, 0, "LoperWit"   ); ds_grid_set(sb, 5, 7, "LoperZwart"   );
ds_grid_set(sb, 6, 0, "PaardWit"   ); ds_grid_set(sb, 6, 7, "PaardZwart"   );
ds_grid_set(sb, 7, 0, "TorenWit"   ); ds_grid_set(sb, 7, 7, "TorenZwart"   );
//Een for-lus maakt het iets makkelijker
for (xx = 0; xx < 8; xx += 1)
{
  ds_grid_set(sb, xx, 1, "PionWit"  );
  ds_grid_set(sb, xx, 6, "PionZwart");
  //De leegte in het midden opvullen
  for (yy = 2; yy < 6; yy += 1)
    ds_grid_set(sb, xx, yy, "Leeg");
}
//Ons schaakbord weer verwijderen
ds_grid_destroy(sb);
Zoals je kan zien, is dit nogal wat typewerk en kan ook veel simpeler gedaan worden. Om te beginnen maken we (in het kort) kennis met de functie:
GML:
ds_grid_clear(nummer, waarde);
Hiermee kunnen we de hele grid vullen met een bepaalde waarde (real) of tekst (string). Omdat in het begin (als je een schaakbord pakt) alle hokjes leeg zijn, kunnen we dus de volgende regel toevoegen na het maken van de grid:
GML:
ds_grid_clear(nummer, "Leeg");
Nu is de extra for-lus (met yy als variabele) niet meer nodig.
De volgende verbetering maakt gebruik van de functie:
GML:
ds_grid_add(nummer, X, Y, waarde);
nummer is vanzelfsprekend het identificatienummer van de grid, net als X en Y de positie aangeven, en waarde geeft aan wat er bij opgeteld moet worden. Deze functie lijkt erg veel op ds_grid_set() - het verschil is dat er nu iets wordt toegevoegd aan de waarde die er al is. Als er een getal op die positie stond, kan je er een getal bij optellen; als er een tekst op die positie stond, kan je er een tekst aan toevoegen ("Hoi, "+"#doei."). Dit laatste kunnen we goed gebruiken voor het schaakbord, aangezien elk stuk "Wit" of "Zwart" is.
De code ziet er nu al heel wat anders uit:
GML:
var xx, yy;

sb=ds_grid_create(8, 8);
ds_grid_clear(sb, "Leeg");
for (yy = 0; yy < 8; yy += 7)
{
  ds_grid_set(sb, 0, yy, "Toren"   );
  ds_grid_set(sb, 1, yy, "Paard"   );
  ds_grid_set(sb, 2, yy, "Loper"   );
  ds_grid_set(sb, 3, yy, "Koningin");
  ds_grid_set(sb, 4, yy, "Koning"  );
  ds_grid_set(sb, 5, yy, "Loper"   );
  ds_grid_set(sb, 6, yy, "Paard"   );
  ds_grid_set(sb, 7, yy, "Toren"   );
}
for (xx = 0; xx < 8; xx += 1)
{
  ds_grid_set(sb, xx, 1, "Pion");
  ds_grid_set(sb, xx, 6, "Pion");
  for (yy = 0; yy < 2; yy += 1)
  {
    ds_grid_add(sb, xx,   yy, "Wit"  );
    ds_grid_add(sb, xx, 7-yy, "Zwart");
  }
}

Nu hebben we wel netjes alle waarden opgeslagen, maar wat heb je eraan als je ze niet kan opvragen? Hiervoor is dé functie uitgevonden:
GML:
ds_grid_get(nummer,X,Y);
Ik hoef onderhand hopelijk niet meer de argumenten uit te leggen, al zeg ik het toch nog 1 keer: Hiermee vraag je de waarde op van het hokje op de positie (X,Y) van de grid nummer. In ons schaakbord zou ds_grid_get(sb, 0, 0) dus als antwoord TorenWit geven. Dit antwoord kan je logischerwijs opslaan in een variabele o.i.d.

Verder is er nog de functie:
GML:
ds_grid_multiply(nummer,X,Y,waarde);
Zoals je waarschijnlijk wel begrijpt, werkt deze functie alleen op hokken waarin een getal staat. ("Hoi" * "A" wil echt niet. Tong) Deze wordt dan vermenigvuldigd met waarde.

In het komende hoofdstuk gaan we het schaakbord nog wat simpeler opstellen:


Regio's

Met regio's bedoel ik dat je met meerdere hokjes tegelijk werkt, met rechthoekig bedoel ik rechthoekig (). Aangezien de vorige zin alleen maar voor meer verwarde hoofdjes zorgt, zal ik het iets duidelijker uitleggen:

Het rode gebied is dus de regio - dit gebied gaat van (3,0) tot en met (5,3).

Rechthoekige regio's

De eerste functie met een regio die je tegenkomt is:
GML:
ds_grid_set_region(nummer, x1, y1, x2, y2, waarde);
Hiermee geef je alle hokjes van (x1,y1) tot en met (x2,y2) de waarde waarde (getal of tekst). Met ds_grid_set_region(sb, 0, 0, ds_grid_width(sb)-1, ds_grid_height(sb)-1, "Leeg") bereik je dus hetzelfde als ds_grid_clear(sb, "Leeg"). (_width en _height worden later uitgelegd.)

Een functie die hier veel op lijkt is:
GML:
ds_grid_add_region(nummer, x1, y1, x2, y2, waarde);
Hiermee voeg je de waarde waarde toe aan de regio - het werkt dus op dezelfde manier als ds_grid_add().

Met deze twee nieuwe functies kunnen we het schaakbord op een geheel nieuwe manier vullen:
GML:
sb = ds_grid_create(8, 8);
ds_grid_clear(sb, "Toren");
ds_grid_set_region(sb, 1, 0, 6, 7, "Paard"   );
ds_grid_set_region(sb, 2, 0, 5, 7, "Loper"   );
ds_grid_set_region(sb, 3, 0, 3, 7, "Koningin");
ds_grid_set_region(sb, 4, 0, 4, 7, "Koning"  );
ds_grid_set_region(sb, 0, 1, 7, 6, "Pion"    );
ds_grid_set_region(sb, 0, 2, 7, 5, "Leeg"    );
ds_grid_add_region(sb, 0, 0, 7, 1, "Wit"     );
ds_grid_add_region(sb, 0, 6, 7, 7, "Zwart"   );
Ook al vul je in het begin de hele grid met torens, er blijven maar 4 torens over, omdat de rest simpelweg vervangen wordt door paarden en pionnen. (door de waarden te overschrijven)

Verder is er nog de functie:
GML:
ds_grid_multiply_region(nummer, x1, y1, x2, y2, waarde);
De functienaam spreekt voor zich: het vermenigvuldigt de waarden van de hokjes in de regio met waarde.

De volgende vier functies behandel ik direct achter elkaar:
GML:
ds_grid_get_sum (nummer, x1, y1, x2, y2);
ds_grid_get_max (nummer, x1, y1, x2, y2);
ds_grid_get_min (nummer, x1, y1, x2, y2);
ds_grid_get_mean(nummer, x1, y1, x2, y2);
ds_grid_get_sum() telt alle waarden in de regio bij elkaar op en geeft de uitkomst.
De andere drie functies werken hetzelfde als de functies min(), max() en mean(), alleen werk je nu niet met een aantal argumenten, maar met een regio.
Zoals je wel begrijpt, werkt dit alleen met getallen. (Nee, zelfs niet als je de tekst "1,5" hebt. Knipoog )
Deze functies zijn erg handig in een RTS (waarbij je een heuvelachtig terrein hebt): door te kijken wat het grootste verschil in hoogte is, kan je zien of het gebouw geplaatst kan worden.

De volgende drie functies behandel ik ook in een keer:
GML:
ds_grid_value_exists(nummer, x1, y1, x2, y2, waarde);
ds_grid_value_x(nummer, x1, y1, x2, y2, waarde);
ds_grid_value_y(nummer, x1, y1, x2, y2, waarde);
ds_grid_value_exists() geeft aan of de waarde waarde ergens voorkomt in de regio. Als dat zo is, kan je met de andere twee functies erachter komen in welk hokje die waarde zit.

Opdracht
Probeer nu eens met al deze functies een werkend schaakspel te maken:


Ronde regio's

Hier kan ik heel kort over zijn, aangezien de functies die hier voorkomen hetzelfde doen als de rechthoekige regio's (alleen zijn de regio's hier rond).
Hier is de lijst van functies die een ronde regio gebruiken:
GML:
ds_grid_set_disk     (nummer, X, Y, straal, waarde);
ds_grid_add_disk     (nummer, X, Y, straal, waarde);
ds_grid_multiply_disk(nummer, X, Y, straal, waarde);

ds_grid_get_disk_sum (nummer, X, Y, straal);
ds_grid_get_disk_min (nummer, X, Y, straal);
ds_grid_get_disk_max (nummer, X, Y, straal);
ds_grid_get_disk_mean(nummer, X, Y, straal);

ds_grid_value_disk_exists(nummer, X, Y, straal, waarde);
ds_grid_value_disk_x(nummer, X, Y, straal, waarde);
ds_grid_value_disk_y(nummer, X, Y, straal, waarde);
Ik zal nog wel even uitleggen wat X, Y en straal inhouden. X en Y zijn de posities van het middelpunt van de cirkel en straal is de straal van de cirkel. (De cirkel is de regio)

Deze functies zijn o.a. geschikt voor A.I. voor het zoeken naar een plek waar hij buiten het bereik van vijandig vuur is. Ook kan dit van toepassing zijn bij een RTS wanneer een gebouw gedraaid kan worden of rond is.


De laatste functies

Hier komen de minder gebruikte (of moeilijkere) functies voor. Als eerst de weinig gebruikte functies:
GML:
ds_grid_resize(nummer, breedte, hoogte);
ds_grid_width (nummer);
ds_grid_height(nummer);
De eerste functie vergroot/verkleint de grid naar de aangegeven breedte en hoogte. Alle waarden die al bestonden blijven staan.
De andere twee functie geven aan hoe breed/hoog de grid is.
GML:
ds_grid_shuffle(nummer);
Deze functie doet niets meer dan de hele grid overhoop halen - deze functie is vooral handig voor puzzelspellen (zoals een schuifpuzzel) en voor het genereren van een willekeurig terrein.

GML:
ds_grid_write(nummer);
Deze functie geeft een tekst terug waarin de inhoud van de grid is opgeslagen. Met de volgende functie kan je die weer uitlezen:
GML:
ds_grid_read(nummer, tekst);
Deze functie verwijdert alle waarden die in grid nummer staan en vult hem met de waarden die in tekst zijn opgeslagen.
Deze twee functies kan je gebruiken om grids op te slaan/versturen, zonder dat je daarvoor eigen scripts moet schrijven. (Bijvoorbeeld tijdens een potje schaken)

De volgende functies zijn voor het verplaatsen van waarden van de ene grid naar de andere:
GML:
ds_grid_copy(nummer, oorsprong);
ds_grid_set_grid_region     (nummer, oorsprong, x1, y1, x2, y2, xpos, ypos);
ds_grid_add_grid_region     (nummer, oorsprong, x1, y1, x2, y2, xpos, ypos);
ds_grid_multiply_grid_region(nummer, oorsprong, x1, y1, x2, y2, xpos, ypos);
De eerste functie leegt de grid nummer en vult het met de waarden uit oorsprong. (Je maakt dus een kopie.) De andere drie functies kopiëren een regio van oorsprong naar nummer, waarbij de positie (xpos,ypos) aangeeft waar de linker bovenhoek van de regio moet komen. Kopiëren van (x1, y1, x2, y2) naar (x1,y1) zorgt er dus voor dat de regio op dezelfde plaats in grid nummer als in grid oorsprong terechtkomt.

Deze functies kun je ook zelf maken voor GM5/GM6:
GML:
//scr_grid_copy(nummer, oorsprong)
var w, h, xx, yy;
w = ds_grid_width(argument1);
h = ds_grid_height(argument1);

ds_grid_resize(argument0, w, h); //Kan een crash veroorzaken
for (xx = 0; xx < w; xx += 1)
  for (yy = 0; yy < h; yy += 1)
    ds_grid_set(argument0, xx, yy, ds_grid_get(argument1, xx, yy));

//scr_grid_set_grid_region(nummer, oorsprong, x1, y1, x2, y2, xpos, ypos);
var xx, yy, xadd, yadd;
xadd = argument6-argument2;
yadd = argument7-argument3;

for (xx = argument2; xx <= argument4; xx+=1)
  for (yy = argument3; yy <= argument5; yy+=1)
    ds_grid_set(argument0, xx+xadd, yy+yadd, ds_grid_get(argument1, xx, yy));

//scr_grid_add_grid_region(nummer, oorsprong, x1, y1, x2, y2, xpos, ypos);
var xx, yy, xadd, yadd;
xadd = argument6-argument2;
yadd = argument7-argument3;

for (xx = argument2; xx<=argument4; xx+=1)
  for (yy = argument3; yy<=argument5; yy+=1)
    ds_grid_add(argument0, xx+xadd, yy+yadd, ds_grid_get(argument1, xx, yy));

//scr_grid_multiply_grid_region(nummer, oorsprong, x1, y1, x2, y2, xpos, ypos);
var xx, yy, xadd, yadd;
xadd = argument6-argument2;
yadd = argument7-argument3;

for (xx = argument2; xx<=argument4; xx+=1)
  for (yy = argument3; yy<=argument5; yy+=1)
    ds_grid_multiply(argument0, xx+xadd, yy+yadd, ds_grid_get(argument1, xx, yy));
N.B.: Deze functies werken niet optimaal wanneer nummer en oorsprong dezelfde grid zijn. (Hiervoor zou een tijdelijke grid aangemaakt moeten worden.)


Updates
30-4-'08:
  ds_grid_shuffle() aangepast n.a.v. Janozua.
01-5-'08:
  Een paar kleine aanpassingen n.a.v. Pallas. Ook komt er een opdracht voor een schaakspel.
03-5-'08:
  Schaakopdracht is klaar. Op verzoek van light heb ik de GM5/GM6 equivalenten voor het kopiëren van grids toegevoegd.

« Laatste verandering: 2 Maart 2009, 19:31:40 door Flumble »
Naar boven Gelogd

Janozua
Gebruiker

Offline Offline

Berichten: 2085


« Antwoord #1 Gepost op: 30 April 2008, 10:25:45 »

Citaat
GML:
ds_grid_shuffle(nummer);
Deze functie doet niets meer dan het hele grid overhoop halen - ik heb niet echt een idee waarvoor dit nuttig kan zijn.
Misschien is deze funtie toch wel handig. Bijvoorbeeld wanneer je een puzzel spel maakt en je alles door elkaar moet gooien.

Verder vind ik deze tutorial erg goed uitgelegt. Het kan best handig zijn, maar ik denk wel dat je dit niet heel erg vaak nodig zult hebben. Maar uiteraard zeg je dat wel eens meer en heb je het achteraf toch nodig. Knipoog
Ik vind het best slim en handig dat je hierbij een voorbeeld hebt gebruikt, namelijk een schaakbord. Dit maakt het is duidelijker, al hoewel ik toch helemaal niet kan schaken vond ik het toch handig.

Naar boven Gelogd

Pallas
Gebruiker


Offline Offline

Berichten: 801

Carpe Diem!


« Antwoord #2 Gepost op: 1 Mei 2008, 11:27:50 »

Janozua schreef:
Citaat
Verder vind ik deze tutorial erg goed uitgelegt. Het kan best handig zijn, maar ik denk wel dat je dit niet heel erg vaak nodig zult hebben. Maar uiteraard zeg je dat wel eens meer en heb je het achteraf toch nodig.

Toen ik voor het eerst de ds_grid functies zag, dacht ik ook dat je het niet vaak ergens voor nodig hebt. Flumble vergelijkt het zelf ook met 2 dimensionale arrays.

Misschien is het handig om toe te voegen dat een voordeel van het gebruik van grids is, dat het sneller is dan 2 dimensionale arrays, omdat we hier al met gecompileerde code te maken hebben.
Ook kan je misschien vertellen dat de ds_grid_write en ds_grid_read functies handig zijn bij het opslaan/laden van spellen. Stel we zijn bezig met een potje schaak en we willen het spel opslaan dan kan je gemakkelijk deze functies gebruiken.


- Voltooid -
Ninjamboree
Het Geheime Wapen
- In ontwikkeling -
Carpe Diem - 75 %
Naar boven Gelogd

light
Gebruiker


Offline Offline

Berichten: 415

1 ruzie minder is een stap naar wereldvrede


WWW
« Antwoord #3 Gepost op: 1 Mei 2008, 22:18:26 »

Ik begrijp het verschil tussen een 2d array en een Grid niet echt, natuurlijk hebben grids ingebouwde functies maar spellen zoals boter kaas en eieren, trax, 3d height collision maak ik toch makkelijker met 2d arrays. Is er geen functie de data te sorteren op hoogte ofzo.
NaamHighscore
Geert42
Kees65
Thijs12
dit zou dan kunnen worden:
NaamHighscore
Kees65
Geert42
Thijs12
Anders blijf ik lekker dwars op de 2d array zitten hoor Tong



Naar boven Gelogd

Flumble
Gebruiker


Offline Offline

Berichten: 2020


« Antwoord #4 Gepost op: 2 Mei 2008, 09:49:29 »

@light
GML:
// scr_sorteer(grid[, sorteerrij]);
// sorteer_rij is de rij waarop de kolommen
// worden gesorteerd. Standaard is de linker rij.
var grootte, rij;
grootte = ds_grid_height(argument0)-1;
rij = argument1;
if (!grootte || rij < 0 || rij >= ds_grid_width(argument0))
  return false;

var kopie, maximum, y1, y2;
kopie = ds_grid_create(1, 1);
maximum = ds_grid_get_max(kopie, rij, 0, rij, grootte);

ds_grid_copy(kopie, argument0);
for (y2 = 0; string(maximum) != ""; y2 += 1)
{
  y1 = ds_grid_value_y(kopie, rij, 0, rij, grootte, maximum);
  ds_grid_set_grid_region(argument0, kopie, 0, y1, grootte, y1, 0, y2);
  ds_grid_set(kopie, rij, y1, "");
  maximum = ds_grid_get_max(kopie, rij, 0, rij, grootte);
}
ds_grid_destroy(kopie);
return true;
Dit is, naar mijn weten, de snelste/kortste manier* om de waarden van een grid te sorteren met alleen het gebruik van grids. Als je nog een andere datastructuur erbij gebruikt, bijvoorbeeld een lijst of prioritaire lijst, kan het makkelijker.
Wel een groot voordeel bij het script hierboven is dat het ook met strings werkt. Knipoog (Sterker nog, je kan zelfs strings en getallen in dezelfde rij gooien en hij sorteert 't nog.)

@iedereen
De schaakopdracht is bijna klaar. ('t Is toch niet zo makkelijk om te kijken welke zetten een bepaald schaakstuk mag doen.)

*zonder foutencontrole is het ietsje korter, maar dit leek me wel zo verstandig.

« Laatste verandering: 2 Maart 2009, 20:04:21 door Flumble »
Naar boven Gelogd

light
Gebruiker


Offline Offline

Berichten: 415

1 ruzie minder is een stap naar wereldvrede


WWW
« Antwoord #5 Gepost op: 3 Mei 2008, 09:29:01 »

ds_grid_copy bestaat niet in GM6 kun je/ik dit vervangen door iets anders? Evenals ds_grid_set_grid_region

« Laatste verandering: 3 Mei 2008, 09:44:21 door light »


Naar boven Gelogd

ChrisCompany
Gebruiker


Offline Offline

Berichten: 1412


WWW
« Antwoord #6 Gepost op: 7 Mei 2008, 20:37:10 »

ds_grid_copy bestaat niet in GM6 kun je/ik dit vervangen door iets anders? Evenals ds_grid_set_grid_region

Kijk helemaal onderin de post, er staat: Deze functies kun je ook zelf maken met gm5/gm6 daarboven staat de script naam en daaronder de code. Zo kun je die functies dus gewoon zelf maken en hoeven ze niet ingebouwd te zijn.

Als dat is toegevoegd nadat die light gepost heeft heb ik niks gezegd  Engel

EDIT:
Ik heb dus niks gezegd >.<

« Laatste verandering: 7 Mei 2008, 20:38:52 door ChrisCompany »

Naar boven Gelogd

Ragoune
Oud-moderator


Offline Offline

Berichten: 1457

Resload.com!


« Antwoord #7 Gepost op: 8 Mei 2008, 10:24:47 »

Hey,

Misschien heb ik het niet gezien ofzo, maar hoe moet je kijken of het volgende vakje vrij is?

Mvg,
Ragoune

Naar boven Gelogd

Flumble
Gebruiker


Offline Offline

Berichten: 2020


« Antwoord #8 Gepost op: 8 Mei 2008, 10:45:30 »

Hoe definieer jij "het volgende vakje"? Is dit een vakje naar rechts (ds_grid_get(x+1,y)), een vakje naar links (ds_grid_get(x-1,y)), een vakje naar onderen (ds_grid_get(x,y+1)) of een vakje naar boven (ds_grid_get(x,y-1))? (Hierbij is (x,y) de positie van het huidige vakje.)

@ChrisCompany
Bij de updates staat vermeld dat ik n.a.v. light dit heb toegevoegd. ;)

Naar boven Gelogd

mori
Gebruiker


Offline Offline

Berichten: 1095


« Antwoord #9 Gepost op: 4 Juni 2011, 22:39:59 »

hoeveel werkgeheugen heb je nodig voor een grid van 100*100? en voor 1000*1000?


Naar boven Gelogd

Flumble
Gebruiker


Offline Offline

Berichten: 2020


« Antwoord #10 Gepost op: 6 Juni 2011, 11:45:50 »

Een simpele test met taakbeheer ernaast zegt dat een grid van 100×100 48KB in beslag neemt en 1000×1000 23MB. Aangezien 48*10*10 geen 23000 is, worden er dus intern ook nog wat variabelen voor delen van het grid opgeslagen. (sterker nog, een grid van 1000×100 is groter dan een grid van 100×1000)

Let wel op dat beide tests met lege grids zijn, dus ze kunnen nog wat groter uitvallen. (en dat zal ook wel, want 4,9bytes per cel in de 100×100 is kleiner dan één gm-variabele)

Naar boven Gelogd

goodboy
Gebruiker


Offline Offline

Berichten: 2766


« Antwoord #11 Gepost op: 6 Juni 2011, 16:22:52 »

Zit er toevallig een virus in de schaak opdracht?
want toen ik het downloadde kreeg ik niet veel later een melding van een mogelijk gevaar.

Naar boven Gelogd

pinda_kaas
Gebruiker


Offline Offline

Berichten: 316

I love pindakaas


« Antwoord #12 Gepost op: 7 Juni 2011, 20:48:11 »

Goeie tut ik wist niet eens waar deze opdrachte voor  diendee had wze wel es op expertform tegen gekomen (benvp best noob Grijns)



Kogles
Naar boven Gelogd

Flumble
Gebruiker


Offline Offline

Berichten: 2020


« Antwoord #13 Gepost op: 8 Juni 2011, 11:21:53 »

Zit er toevallig een virus in de schaak opdracht?
want toen ik het downloadde kreeg ik niet veel later een melding van een mogelijk gevaar.
Het zou sowieso niet mogen kunnen dat er een virus in een onuitvoerbaar bestand zit, maar ik heb ze voor de zekerheid even laten scannen door virustotal: niets en niets.

Naar boven Gelogd

pinda_kaas
Gebruiker


Offline Offline

Berichten: 316

I love pindakaas


« Antwoord #14 Gepost op: 26 Augustus 2011, 14:28:05 »

Bij jou oplossingen zit een bug zoals iedereen (hoort) weet kan je passant slaan met een pion

link: http://nl.wikipedia.org/wiki/En_passant_slaan



Kogles
Naar boven Gelogd

Advertenties
« vorige volgende »
Pagina's: [1] 2
Print


Topic Informatie
0 geregistreerde leden en 1 gast bekijken dit topic.

Ga naar:  

Powered by SMF 1.1.21 | SMF © 2006-2007, Simple Machines
www.game-maker.nl © 2003-2022 Nederlandse Game Maker Community