<?xml version="1.0" encoding="UTF-8"?>
<rss version="2.0" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:dc="http://purl.org/dc/elements/1.1/">
	<channel>
		<copyright>Copyright 1998 - 2023 DPG Media B.V.</copyright>
		<pubDate>Wed, 11 Jan 2023 22:19:33 GMT</pubDate>
		<lastBuildDate>Wed, 11 Jan 2023 22:19:33 GMT</lastBuildDate>
		<docs>https://tweakers.net/reviews/76</docs>
		<description>Tweakblogs.net is de weblog service van Tweakers, de grootste hardwaresite en techcommunity van Nederland.</description>
		<image>
			<link>https://tweakblogs.net/</link>
			<title>Tweakblogs.net</title>
			<url>https://tweakers.net/g/if/logo.gif</url>
			<height></height><width></width>
			<description>Tweakblogs.net</description>
		</image>
		<language>nl-nl</language>
		<link>https://tommasso.tweakblogs.net</link>
		<title>Tommasso</title>
		<webMaster>gathering@tweakers.net</webMaster>
		<item>
			<title>Post 0x02</title>
			<link>https://tommasso.tweakblogs.net/blog/7120/post-0x02.html#r_96265</link>
			<description>Code (screw you postlimit!):
C#:1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
spriteBatch.Begin(SpriteSortMode.Deferred, BlendState.AlphaBlend);
int col, row;
int scrX, scrY, mapX, mapY;
int terrainTypeFrameIndex;


// start drawing!
scrX = draw_startScrX;
scrY = draw_startScrY;
mapX = draw_startMapX;
mapY = draw_startMapY;
int i;
for (i = 0; i &lt; 2; i++)
{
    for (col = 0; scrX &lt; screenWidth; col++)
    {
        for (row = 0; scrY &lt; screenHeight; row++)
        {
            if (mapX &gt;= 0 &amp;&amp; mapX &lt; map.GetLength(0) &amp;&amp; mapY &gt;= 0 &amp;&amp; mapY &lt; map.GetLength(1))
            {
                terrainTypeFrameIndex = mapY % 10 * 10 + mapX % 10;
                spriteBatch.Draw(textures[terrainTypes[map[mapX, mapY]].slp].frames[terrainTypeFrameIndex], new Vector2(scrX, scrY), Color.White);

                // check for neighbours
                List&lt;int&gt; prioritiesList = new List&lt;int&gt;();
                List&lt;int&gt; neighbourTypesList = new List&lt;int&gt;();
                int[,] neighbours = new int[3, 3];

                for (int j = 0; j &lt; 3; j++)
                {
                    for (int jj = 0; jj &lt; 3; jj++)
                    {
                        if (j + mapX - 1 &gt;= 0 &amp;&amp; j + mapX - 1 &lt; map.GetLength(0) &amp;&amp; jj + mapY - 1 &gt;= 0 &amp;&amp; jj + mapY - 1 &lt; map.GetLength(1))
                        {
                            if (terrainTypes[map[j + mapX - 1, jj + mapY - 1]].priority &gt; terrainTypes[map[mapX, mapY]].priority)
                            {
                                prioritiesList.Add(terrainTypes[map[j + mapX - 1, jj + mapY - 1]].priority);
                                neighbourTypesList.Add(map[j + mapX - 1, jj + mapY - 1]);
                            }
                            neighbours[j, jj] = map[j + mapX - 1, jj + mapY - 1];
                        }
                        else{
                            neighbours[j, jj] = map[mapX, mapY];
                        }
                    }
                }

                int[] priorities = prioritiesList.ToArray();
                int[] neighbourTypes = neighbourTypesList.ToArray();
                Array.Sort(neighbourTypes, priorities);
                for (int ii = 0; ii &lt; neighbourTypes.Length; ii++)
                {
                    int direction = getDirection(neighbours, neighbourTypes[ii], new int[2] { mapX, mapY });
                    int[] mask = blendMasks[terrainTypes[map[mapX, mapY]].blendmode][direction];
                    Color[] colors = drawSlpFile(terrainTypes[neighbourTypes[ii]].slp, terrainTypeFrameIndex, 0);

                    // start blending
                    int rowWidth = 1;
                    int pos = 0;
                    bool half = false;
                    for (int imageRow = 0; imageRow &lt; 49; imageRow++)
                    {

                        int xOffset = 48 - rowWidth / 2;
                        for (int imageCol = xOffset; imageCol &lt; xOffset + rowWidth; imageCol++)
                        {
                            colors[imageRow * 97 + imageCol].A = (byte)((127 - mask[pos] / 128f * 127) * 2);
                            pos++;
                        }
                        if (rowWidth == 97)
                        {
                            half = true;
                        }
                        if (half == false) rowWidth += 4;
                        else rowWidth -= 4;
                    }

                    Texture2D texture = new Texture2D(device, 97, 49, false, SurfaceFormat.Color);
                    texture.SetData(colors);
                    spriteBatch.Draw(texture, new Vector2(scrX, scrY), new Color(256, 256, 256, 256));
                }
                spriteBatch.DrawString(font, mapX + &quot; &quot; + mapY, new Vector2(scrX + 30, scrY + 15), Color.Red);
                spriteBatch.DrawString(font, terrainTypeFrameIndex + &quot;&quot;, new Vector2(scrX + 30, scrY + 25), Color.Red);
            }
            scrY += imageHeight;
            mapX--;
            mapY++;
        }
        scrX += imageWidth;
        scrY -= imageHeight * row;
        mapX += row + 1;
        mapY -= row - 1;
    }
    scrX = draw_startScrX + imageWidth / 2;
    scrY = draw_startScrY - imageHeight / 2;
    mapX = draw_startMapX + 1;
    mapY = draw_startMapY;
}
spriteBatch.End();</description><dc:creator>Tommasso</dc:creator>
			<category></category>
			<comments>https://tommasso.tweakblogs.net/blog/7120/post-0x02.html#r_96265#reacties</comments>
			<guid isPermaLink="false">https://tommasso.tweakblogs.net/blog/7120#r_96265</guid>
			<pubDate>Sun, 02 Oct 2011 08:03:26 GMT</pubDate>
		</item>
		<item>
			<title>Post 0x01</title>
			<link>https://tommasso.tweakblogs.net/blog/7039/post-0x01.html#r_95076</link>
			<description>@RobIII
In PHP ben ik het probleem niet tegengekomen. Daar was het altijd keurig 3.1 ed (ik ben denk ik gewoon lui en gewend aan het gemak van PHP ) Maar ik zal aan mijn code prutsen zodat mijn coor wat netter worden...

@Voxyn
Ik denk dat die map openen wat onafgewerkt gedebug is. Ik had ook het bestand geprobeerd te openen. Ik had alleen die @ niet, dus deed ie het nie .
Maar ik heb nu blendomatic en terrain succesvol kunnen uitlezen:
C#:1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
void loadTerrainData(){
            StreamReader sr = new StreamReader(@&quot;C:/Program Files (x86)/Age of Empires II/Data/ged_data/text/terrain.txt&quot;);
            // skip first 21 lines
            int i;
            for (i = 0; i &lt; 21; i++)
            {
                sr.ReadLine();
            }
            string name, line;
            int slp, priority, blendmode, sizeX, sizeY;
            string [] segment;

            List&lt;TerrainType&gt; list = new List&lt;TerrainType&gt;();
            // start reading the file
            for(i = 0; sr.Peek() &gt;= 0; i++){
                line = sr.ReadLine(); // ignore line

                line = sr.ReadLine();
                segment = line.Split(new Char [] {&#039; &#039;});
                name = segment[1];
                
                line = sr.ReadLine(); // ignore line

                line = sr.ReadLine();
                segment = line.Split(new Char [] {&#039; &#039;});
                int.TryParse(segment[1], out slp);

                line = sr.ReadLine();
                segment = line.Split(new Char [] {&#039; &#039;});
                int.TryParse(segment[3], out priority);
                int.TryParse(segment[4], out blendmode);

                line = sr.ReadLine(); // ignore line

                line = sr.ReadLine(); // ignore line

                sizeX = 10;
                sizeY = 10;

                list.Add(new TerrainType(name, slp, priority, blendmode, sizeX, sizeY));
            }
            terrainTypes = list.ToArray();
            sr.Close();
        }
        void loadBlendData()
        {
            BinaryReader br = new BinaryReader(File.Open(@&quot;C:/Program Files (x86)/Age of Empires II/Data/blendomatic.dat&quot;, FileMode.Open));
            int blendmodes = br.ReadInt32();
            int directions = br.ReadInt32();

            int pixelsPerTile;
            blendMasks = new int [blendmodes][][];

            for (int i = 0; i &lt; blendmodes; i++)
            {
                pixelsPerTile = br.ReadInt32();
                blendMasks[i] = new int[directions][];

                // start reading
                br.ReadBytes(directions); // skip useless data
                br.ReadBytes(pixelsPerTile * 4); // skip useless data

                for (int ii = 0; ii &lt; directions; ii++)
                {
                    blendMasks[i][ii] = new int[pixelsPerTile];
                    for (int iii = 0; iii &lt; pixelsPerTile; iii++)
                    {
                        blendMasks[i][ii][iii] = br.ReadByte();
                    }
                }
            }
        }
Wat een gedoe om een dynamic array werkend te krijgen, of ben ik nou gek?
Bedankt voor de hulp!

Next up is het ontleden van DRS en SLP bestanden, wordt gek van die duizenden images in mijn project .</description><dc:creator>Tommasso</dc:creator>
			<category></category>
			<comments>https://tommasso.tweakblogs.net/blog/7039/post-0x01.html#r_95076#reacties</comments>
			<guid isPermaLink="false">https://tommasso.tweakblogs.net/blog/7039#r_95076</guid>
			<pubDate>Mon, 05 Sep 2011 08:04:59 GMT</pubDate>
		</item>
		<item>
			<title>Post 0x01</title>
			<link>https://tommasso.tweakblogs.net/blog/7039/post-0x01.html#r_95013</link>
			<description>en als ik het bestand niet importeer maar benader vanuit de code wilt het niet werken: het bestand kan dan niet worden gevonden.Je probeert een map te openen en niet een bestand .

code:1
StreamReader sr = new StreamReader(&quot;C:/Program Files (x86)/Age of Empires II/Data/ged_data/terrain&quot;); 
Zo kan je het proberen:

code:1
StreamReader sr = new StreamReader(@&quot;C:/Program Files (x86)/Age of Empires II/Data/ged_data/terrain/&quot; + filename);

verder kan je en bestand helemaal van begin tot einde uitlezen met de functie sr.ReadToEnd()

zal dus waarschijnlijk zoiets worden:
code:1
2
3
4
5
6
7
8
9
10
11
void loadBlendomaticData()
        {
            StreamReader sr = new StreamReader(@&quot;C:/Program Files (x86)/Age of Empires II/Data/ged_data/blendomatic.dat&quot;);

            string text = &quot;&quot;;

            text = sr.ReadToEnd();
            //close the stream
            sr.Close();

        }


Hoop dat je hier in ieder geval een beginnetje mee hebt, hoor graag een reactie of je iets aan hebt .</description><dc:creator>Voxyn</dc:creator>
			<category></category>
			<comments>https://tommasso.tweakblogs.net/blog/7039/post-0x01.html#r_95013#reacties</comments>
			<guid isPermaLink="false">https://tommasso.tweakblogs.net/blog/7039#r_95013</guid>
			<pubDate>Fri, 02 Sep 2011 22:57:00 GMT</pubDate>
		</item>
		<item>
			<title>Post 0x01</title>
			<link>https://tommasso.tweakblogs.net/blog/7039/post-0x01.html#r_94997</link>
			<description>Tommasso schreef op vrijdag 02 september 2011 @ 16:46:

Maar thx voor de links, ben nogal noob in C# Wat betreft je float &quot;probleem&quot;; dat is inherent aan floats (en dus ook het geval bij PHP of eender welke andere taal) en niet C# specifiek  (en valt IMHO onder basiskennis programmeren)</description><dc:creator>RobIII</dc:creator>
			<category></category>
			<comments>https://tommasso.tweakblogs.net/blog/7039/post-0x01.html#r_94997#reacties</comments>
			<guid isPermaLink="false">https://tommasso.tweakblogs.net/blog/7039#r_94997</guid>
			<pubDate>Fri, 02 Sep 2011 14:51:31 GMT</pubDate>
		</item>
		<item>
			<title>Post 0x01</title>
			<link>https://tommasso.tweakblogs.net/blog/7039/post-0x01.html#r_94996</link>
			<description>Omdat ik al een andere blogpost hierover had gemaakt en ik dus de &#039;serie&#039; hiermee voortzet .
(en ik wou effe de source posten)

Maar thx voor de links, ben nogal noob in C# </description><dc:creator>Tommasso</dc:creator>
			<category></category>
			<comments>https://tommasso.tweakblogs.net/blog/7039/post-0x01.html#r_94996#reacties</comments>
			<guid isPermaLink="false">https://tommasso.tweakblogs.net/blog/7039#r_94996</guid>
			<pubDate>Fri, 02 Sep 2011 14:46:43 GMT</pubDate>
		</item>
		<item>
			<title>Post 0x01</title>
			<link>https://tommasso.tweakblogs.net/blog/7039/post-0x01.html#r_94994</link>
			<description>Verder worden de X en Y coördinaten erg vreemde waardes zoals 3.99999957. Heeft dit te maken met float precision ofzo?Getallen en talstelsels FAQIn PHP gebruikte ik hiervoor fread(), maar in C# slaag ik er niet in om een soortgelijke functie te vinden (ik vind enkel in functies die het bestand lijn voor lijn uitlezen. Hiermee kan ik blendomatic.dat nooit uitlezen.) Kennen jullie een functie die hiervoor wel geschikt is?Alles wat je nodig hebt zit in System.IO

Mag ik vragen waarom je dit in een blogpost aankaart en niet in [PRG]? </description><dc:creator>RobIII</dc:creator>
			<category></category>
			<comments>https://tommasso.tweakblogs.net/blog/7039/post-0x01.html#r_94994#reacties</comments>
			<guid isPermaLink="false">https://tommasso.tweakblogs.net/blog/7039#r_94994</guid>
			<pubDate>Fri, 02 Sep 2011 14:11:44 GMT</pubDate>
		</item>
		<item>
			<title>Post 0x00</title>
			<link>https://tommasso.tweakblogs.net/blog/7003/post-0x00.html#r_94638</link>
			<description>wellicht hier eens kijken? http://wildfiregames.com/0ad/</description><dc:creator>houthakker</dc:creator>
			<category></category>
			<comments>https://tommasso.tweakblogs.net/blog/7003/post-0x00.html#r_94638#reacties</comments>
			<guid isPermaLink="false">https://tommasso.tweakblogs.net/blog/7003#r_94638</guid>
			<pubDate>Fri, 26 Aug 2011 08:08:31 GMT</pubDate>
		</item>
		<item>
			<title>Post 0x00</title>
			<link>https://tommasso.tweakblogs.net/blog/7003/post-0x00.html#r_94550</link>
			<description>Ik heb mij ook eens bezig gehouden met html5/css3 en in JS dus een pathfinding algoritme uitgewerkt waarna het karakter dmv css3 animation naar de bestemming gaat.

http://dl.dropbox.com/u/1...ntend/documents/test.html

Edit: volgens mij enkel in webkit browsers, het is al een hele tijd geleden en moet het nog eens cross-browser maken.</description><dc:creator>Hipska</dc:creator>
			<category></category>
			<comments>https://tommasso.tweakblogs.net/blog/7003/post-0x00.html#r_94550#reacties</comments>
			<guid isPermaLink="false">https://tommasso.tweakblogs.net/blog/7003#r_94550</guid>
			<pubDate>Wed, 24 Aug 2011 21:29:38 GMT</pubDate>
		</item>
		<item>
			<title>Post 0x00</title>
			<link>https://tommasso.tweakblogs.net/blog/7003/post-0x00.html#r_94501</link>
			<description>Had AoE 2 niet een unit-limiet van 200 per player ofzo ? En vergis je niet in HTML 5 hoor;  de rendering is lightning fast, maar het is wel belangrijk dat je code ervoor geoptimaliseerd is en je de juiste technieken/methodieken/algo&#039;s gebruikt.</description><dc:creator>SKiLLa</dc:creator>
			<category></category>
			<comments>https://tommasso.tweakblogs.net/blog/7003/post-0x00.html#r_94501#reacties</comments>
			<guid isPermaLink="false">https://tommasso.tweakblogs.net/blog/7003#r_94501</guid>
			<pubDate>Wed, 24 Aug 2011 14:43:05 GMT</pubDate>
		</item>
		<item>
			<title>Post 0x00</title>
			<link>https://tommasso.tweakblogs.net/blog/7003/post-0x00.html#r_94485</link>
			<description>Ik heb blendomatic.dat zelf ontleend met de onderstaande instructies (eerste succesvolle HEX-job, ):
code:1
2
3
4
5
6
7
8
9
10
11
12
uint32: nr of blending modes (9)
uint32: nr of tiles(31)
for (i=0;i&lt;nr of blendingmodes)
{
  uint32: tilesize(2353, that`s 48*49 pixels);
  31bytes: tileflags(they are all 1);
  4*blocksize bytes which are 32 interleaved tiles representing 1 bit alpha masks, don&#039;t know how this is used for
  for (j=0;j&lt;nr of tiles)
  {
    blocksize bytes: the actual tile pixels; starting from the top .. rendered in the isometric tile format
  }
}

Helaas komen ook bij mij pixels voor die de waarde 128 hebben. Dus ook ik heb te maken met een range van 129 (of ben ik gek en is een bereik van 0 tot met 128 slechts zeven bits lang?). Ik zie bij de overgang van grass naar desert duidelijk dat er te veel desert aanwezig is. Omdat grass hier het dominante terrein is, betekent dit dat de transparantie te hoog is. Immers wordt eerst desert getekend waar vervolgens het grass overheen getekend wordt. Omdat in PHP een hogere waarde betekent dat iets meer transparant is, is dus mijn alpha-waarde te hoog.

De functie waarmee het blendomatic.dat bestand heb ontleed:
PHP:1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
&lt;?php
$fp = fopen(&quot;blendomatic.dat&quot;, &quot;rb&quot;);

$blendmodes = fread($fp, 4);
$blendmodes = end(unpack(&quot;i&quot;, $blendmodes));
$directions = fread($fp, 4);
$directions = end(unpack(&quot;i&quot;, $directions));

for($i = 0; $i &lt; $blendmodes; $i++){
    $pixelsPerTile = fread($fp, 4);
    $pixelsPerTile = end(unpack(&quot;i&quot;, $pixelsPerTile));
    fread($fp, 31); // skip data
    fread($fp, 9412); // skip 1-bit data
    for($ii = 0; $ii &lt; $directions; $ii++){
        for($iii = 0; $iii &lt; $pixelsPerTile; $iii++){
            $tmp = unpack(&quot;C&quot;, fread($fp, 1));
            $data[$i][$ii][$iii] = $tmp[1];
        }
    }
}
//print_r($data);
echo(ftell($fp));
for($i = 0; $i &lt; $blendmodes; $i++){
    for($ii = 0; $ii &lt; $directions; $ii++){
        $imageWidth = 1;
        $iii = 0;
        $half = FALSE;
        $output = imagecreatetruecolor(97, 49);
        for($row = 0; $row &lt; 96; $row++){
            $xOffset = 48 - (int) floor($imageWidth / 2);
            for($col = $xOffset; $col &lt; $xOffset + $imageWidth; $col++){
                imagesetpixel($output, $col, $row, imagecolorallocatealpha( $output, 128 - $data[$i][$ii][$iii], 128 - $data[$i][$ii][$iii], 128 - $data[$i][$ii][$iii], 0));
                $iii++;
            }
            if($imageWidth == 97) $half = TRUE;
            if($half == FALSE) $imageWidth += 4;
            else  $imageWidth -= 4;
        }
        imagepng($output, &#039;blendomatic_&#039; . $i . &#039;_&#039; . $ii . &#039;.png&#039;);
        imagedestroy($output);
    }
}
?&gt;
En mijn blend functies:
PHP:1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
&lt;?php
function imagealphamask($picture, $mask ) {
    // Get sizes and set up new picture
    $xSize = $GLOBALS[&#039;CFG&#039;][&#039;imageWidth&#039;];
    $ySize = $GLOBALS[&#039;CFG&#039;][&#039;imageHeight&#039;];
    $newPicture = imagecreatetruecolor( $xSize, $ySize );
    imagesavealpha( $newPicture, true );
    imagefill( $newPicture, 0, 0, imagecolorallocatealpha( $newPicture, 0, 0, 0, 127 ) );
   
    // Perform pixel-based alpha map application
    for( $x = 0; $x &lt; $xSize; $x++ ) {
        for( $y = 0; $y &lt; $ySize; $y++ ) {
            $alpha = imagecolorsforindex( $mask, imagecolorat( $mask, $x, $y ) );
            $alpha = 127 - round($alpha[&#039;red&#039;] / 128 * 127); // Q&amp;D fix!
            $color = imagecolorsforindex( $picture, imagecolorat( $picture, $x, $y ) );
            imagesetpixel( $newPicture, $x, $y, imagecolorallocatealpha( $newPicture, $color[ &#039;red&#039; ], $color[ &#039;green&#039; ], $color[ &#039;blue&#039; ], $alpha ) );
        }
    }
   
    // Copy back to original picture
    imagedestroy( $picture );
    return $newPicture;
}
function getMask($bm, $index){
    return ImageCreateFromPNG(&#039;blendomatic_&#039; . $bm . &#039;_&#039; . $index . &#039;.png&#039;);
}
function blend($tileFrame, $mask){
    global $terrainTypes, $map, $CFG;
    global $mapCol, $mapRow;
    global $renderX, $renderY;
    global $result;
    global $terrain;
    global $tileFrameIndex, $filenamePostfix;
    
//  imagepng($mask, &#039;&#039; . (microtime(TRUE) - $time) . &#039;mask.png&#039;);
    $tmp = imagealphamask(ImageCreateFromGIF(&#039;G&#039; . $terrainTypes[$terrain][&#039;slp&#039;] . leading_zeros($tileFrameIndex, 2) . $filenamePostfix), $mask);
//  imagepng($tmp, &#039;&#039; . (microtime(TRUE) - $time) . &#039;tmp.png&#039;);
    imagecopy($result, $tmp, $renderX, $renderY - $map[&#039;elevation&#039;][$mapRow][$mapCol] * $CFG[&#039;imageHeight&#039;] / 2, 0, 0, $CFG[&#039;imageWidth&#039;], $CFG[&#039;imageHeight&#039;]);
}
?&gt;
als iemand ergens een bug ziet, laat mij weten!

@DexterDee
Dat is inderdaad een worst-case scenario, en ik realiseer me dat ook Age of Emprires II zelf hier moeite mee zal hebben. Maar een situatie waar rond de 1000 units met elkaar vechten heb ik al vaak meegemaakt en moet ook gewoon kunnen. Alleen betwijfel ik of dit in een browser gaat lukken.
Met die 80.000 units had ik het niet over het tekenen ervan maar over het bijhouden ervan (de simulatie, schade opnemen, sterven maar ook bijvoorbeeld het verwijderen van de unit als deze opnieuw wordt verkend en in de tussentijd is verdwenen.). Er is een verschil tussen het enkel tekenen van objecten op het scherm en het werkelijk bijhouden van een simulatie/spel. Volgens mij kan je ervan uitgaan dat ongeveer 20 a 30% van de processor moet worden benut hier aan. Ik zal kijken of ik morgen tijd heb om met canvassen te gaan werken.
Overigens is die fishie bij mij niet sneller dan 5FPS. Ik denk dat mijn Firefox nogal verrot is .

@l1dert
ik denk dat je gelijk hebt. Dat zijn zaken waar ik totaal geen verstand van heb.

Overigens als iemand anders behoefte heeft om aan dit project mee te helpen/werken zeg ik: elke hulp is welkom.

o ja, ook bij mij zijn er negen overgangsvormen uit de blendomatic.dat gekomen en zit ice blending op een verkeerde plek (zit hier nog een conversie tabel tussen ofzo?)</description><dc:creator>Tommasso</dc:creator>
			<category></category>
			<comments>https://tommasso.tweakblogs.net/blog/7003/post-0x00.html#r_94485#reacties</comments>
			<guid isPermaLink="false">https://tommasso.tweakblogs.net/blog/7003#r_94485</guid>
			<pubDate>Wed, 24 Aug 2011 11:52:08 GMT</pubDate>
		</item>
		<item>
			<title>Post 0x00</title>
			<link>https://tommasso.tweakblogs.net/blog/7003/post-0x00.html#r_94475</link>
			<description>OpenGL is echt niet nodig hiervoor dit is een gewone 2D game. Het kan natuurlijk wel, maar het is ook prima mogelijk om dit op andere manieren te doen. Het eerder genoemde XNA Framework is relatief simpel om te gebruiken. 

Maar ik denk dat het goed mogelijke is om dit in de browser te doen. Je kan proberen om het als javascript/html 5 app te bouwen. Waarschijnlijk moet je dan heel veel gaan optimaliseren. Een andere mogelijkheid is om een flash / silverlight te gebruiken.</description><dc:creator>l1dert</dc:creator>
			<category></category>
			<comments>https://tommasso.tweakblogs.net/blog/7003/post-0x00.html#r_94475#reacties</comments>
			<guid isPermaLink="false">https://tommasso.tweakblogs.net/blog/7003#r_94475</guid>
			<pubDate>Wed, 24 Aug 2011 09:10:10 GMT</pubDate>
		</item>
		<item>
			<title>Post 0x00</title>
			<link>https://tommasso.tweakblogs.net/blog/7003/post-0x00.html#r_94474</link>
			<description>Je rekent nu voor jezelf het worst-case scenario door en dat is waar je de fout ingaat. Met de maximale getallen zoals jij ze schetst zal Age of Empires het zelf ook moeilijk hebben. Sowieso is de kans erg klein dat het je gaat lukken om in je eentje de volledige featureset te implementeren van een AoE, in welke programmeertaal dan ook. Als dat al lukt ben je er jaren en jaren mee bezig.

Je hoeft geen 80.000 objecten te renderen, alleen alle objecten in je viewport. Dat scheelt sowieso al een hele hoop. Dit is zelfs uitermate essentieel voor bijvoorbeeld de performance in 3D spellen (frustom culling). Door klein te beginnen (niet te groot terrein, niet teveel objecten) kun je de performance redelijk op peil houden. Browsers van tegenwoordig zijn steeds meer krachtpatsers op grafisch gebied. Hier een paar voorbeelden:
http://webglsamples.googlecode.com/hg/aquarium/aquarium.html
http://data-arts.appspot.com/globe-search
http://people.mozilla.org/~jmuizelaar/fishie/fishie-gl.html
In het laatste voorbeeld kan ik met mijn laptop met 10.000 vissen op het scherm nog een framerate van 24/sec halen. Dat is al veel meer dan je ooit nodig zult hebben in de viewport van een spelletje als deze.

Als je je verwachtingspatroon en &quot;scope&quot; van je hobbyprojectje wat bijstelt, dan is de browser echt wel haalbare kaart.</description><dc:creator>DexterDee</dc:creator>
			<category></category>
			<comments>https://tommasso.tweakblogs.net/blog/7003/post-0x00.html#r_94474#reacties</comments>
			<guid isPermaLink="false">https://tommasso.tweakblogs.net/blog/7003#r_94474</guid>
			<pubDate>Wed, 24 Aug 2011 08:57:04 GMT</pubDate>
		</item>
		<item>
			<title>Post 0x00</title>
			<link>https://tommasso.tweakblogs.net/blog/7003/post-0x00.html#r_94473</link>
			<description>64K bomen? Ik denk dat je met 10 bomen toekomt. 10 unieke bomen. Dat je elk van die bomen 1000 keer op het terrein zet maakt voor de gamelogic niets uit. Het kopieren van de boomafbeelding in de schermbuffer zou snel genoeg moeten zijn. Das slechts 1 keer lezen en vervolgens 1000 adressen berekenen en 1000 stukjes geheugen kopieren. Tenslotte is een string ook maar een herhaling van dezelfde karakters en om de afbeeldingen van de letters te printen heb je ook niet veel tijd nodig.
Zelfde geld voor de mannetjes. 30 animaties en 10 kleuren maakt 300 &quot;objecten&quot;.

Petje af voor wat je tot nu toe al verwezenlijkt hebt.
BTW ipv opengl te gebruiken kan je een rendering engine gebruiken van een hoger abstractieniveau waardoor je met wat standaard C++ kennis weg kunt komen. eg http://www.ogre3d.org/</description><dc:creator>Punkie</dc:creator>
			<category></category>
			<comments>https://tommasso.tweakblogs.net/blog/7003/post-0x00.html#r_94473#reacties</comments>
			<guid isPermaLink="false">https://tommasso.tweakblogs.net/blog/7003#r_94473</guid>
			<pubDate>Wed, 24 Aug 2011 08:54:25 GMT</pubDate>
		</item>
		<item>
			<title>Post 0x00</title>
			<link>https://tommasso.tweakblogs.net/blog/7003/post-0x00.html#r_94462</link>
			<description>@voxyn
Ik ga er meteen naar kijken!

@DexterDee
Thanks!

Het werken met PHP is idd nogal onhandig... Ik heb nu namelijk zo gemaakt dat nadat de output af is deze wordt opgeslagen in een bestand en deze daarna door de browser weer wordt ingeladen. Die 10 sec is dus enkel de PHP render-time, Firefox heeft nog ong 1 sec nodig om alles in te laden (vooral als ik hem op 1080 instel..., dan is die image ongeveer 2MB).

Het uitlezen en schrijven van pixels lijken idd het probleem te zijn. Tussen no-blend en blend zit een factor van 100 qua render-time. Met ImageMagick ed heb ik nog niet veel gewerkt. Dit project begon ook als uitdaging om meer met afbeeldingen te kunnen spelen .

Ik had idd om de snelheidsproblemen in te demmen al een versie gemaakt waarbij de browser het renderen deed (dit was wel in &lt;img style=&quot;position: absolute;&quot;&gt; stijl), maar dit was nog slomer. Met canvas heb ik nog niet veel gewerkt en ben ik ook nu mee aan het experimenteren. Ik heb wel iets wat enigzins vergelijkbaar is gevonden: http://www.canvasdemos.com/2010/12/13/bencity/. Maar dit project is op mijn computer erg sloom (scrollen duurt ~.5 seconden) en daar wordt (zo ver ik weet) nog niet eens geblend. Ik concludeerde eigenlijk dat canvas ook niet voldeed.

De tiles zijn als .GIF opgeslagen en worden enkel op de output image weggeschreven (tenzij blending nodig is). Ik heb al een cache met daarin al eerder gebruikte tiles in gebruik. 
Het maken van 5x5 vlakken is een erg goed idee! Was is zelf niet op gekomen . Al lijkt het mij wel dat je wel wat &quot;logic overhead&quot; gaat krijgen (elke keer moet je dus checken of de 24 andere tiles ook van dat type zijn, of de daar omringende tiles geen dominant terrein hebben en of er geen berg is. Al denk ik dat dit allemaal wel meevalt (is meer werk, bah ).

Het genereren van terrein op het scherm moet wel haalbaar zijn in JS ed, maar stel dat we het hele scherm willen vullen met villagers welke lopen. Per tile kunnen er 5 villagers staan ofzo (schatting) en er kunnen 1920 / 96 * 2  *  1080 / 48 = 900 tiles in een scherm (en als je met bergen werkt kunnen het er nog meer zijn). Dus kunnen er 4500 villagers op een scherm passen. Maar als je bijv archers hebt schieten deze ook nog arrows en dus kan je zeggen dat er ~9000 items op een scherm staan. Ik denk eerlijk gezegd simpelweg dat zoiets niet haalbaar is met JS. Zelfs om dit in een native applicatie te kunnen laten draainen wordt denk ik al lastig...

Ik heb nog een paar dingen bedacht welke de CPU nog meer gaan belasten:
Zo schat ik in dat op een map van 256x256 het mogelijk is dat er rond de 80000 objecten kunnen zijn (hele map kan bomen zijn: 256 * 256 = 65536, er kunnen 8 players met 200 units rondlopen = 1600 welke meerdere kogels kunnen schieten (castle, chi yo) dus 1600 * 2, er kunnen gebouwen zijn (mss wel 1000 per player) dus 8000 en je hebt nog vogels ed). Er moeten dus constant 80000 objecten worden nagelopen op elke game-turn, ik denk dat hier aardig wat CPU power in gaat zitten.
Verder zijn de afbeeldingen allemaal in een .slp formaat opgeslagen. Dit is een formaat waar per bestand meerdere frame&#039;s worden opgeslagen (villager, walking is bijv 1 slp) Je kan de afbeeldingen niet zomaar als .GIF gaan opslaan omdat er player-colours zijn en als een unit achter een boom staat er een soort &quot;glow&quot; komt. Ik ben bezig met het uitfutsellen van dit formaat...

Ik denk zelf dat de browser een dood eind is (helaas, moet ik met DirectX/OpenGL werken, geen zin in)

btw, ik ben niet een webontwikkelaar, slechts een hobby-ist . Die websites waren voor het vak Informatica.

@Ram0n
Ja, ik wil er wel mee verder gaan. Maar moet eerst echt die preformance issues oplossen. Daarna moet ik blendomatic.dat zelf helemaal doornemen (daar ben ik al aardig ver mee )
Source zal ik zosnel mogelijk online zetten. Kan trouwens niet op pastebin, moet een zip worden (meerdere files, de tiles enz), was daar een goede plek voor? (normaal gooi ik dat op een willekeurige site van mij (freehost...), maar dat doe ik nu liever niet)

@ andere suggesties
Ik zal er allemaal naar kijken, maar neem wss de makkelijkste  (Dat wordt denk ik DirectX, OpenGL vind ik lastiger te begrijpen zover ik er überhaupt iets van snap .

@Sgreehder
Ja, wss vind ik het wiel opnieuw uit, maar ging mij vooral om het leren omgaan met afbeeldingen (dat was het oorspronkelijke doel)</description><dc:creator>Tommasso</dc:creator>
			<category></category>
			<comments>https://tommasso.tweakblogs.net/blog/7003/post-0x00.html#r_94462#reacties</comments>
			<guid isPermaLink="false">https://tommasso.tweakblogs.net/blog/7003#r_94462</guid>
			<pubDate>Tue, 23 Aug 2011 19:20:44 GMT</pubDate>
		</item>
		<item>
			<title>Post 0x00</title>
			<link>https://tommasso.tweakblogs.net/blog/7003/post-0x00.html#r_94456</link>
			<description>Programmeer ervaring had ik eigenlijk helemaal niet maar met sfml heb ik al mooie dingen gemaakt. Het is eigenlijk een soort sdl maar ik vind persoonlijk de leercurve van sdl iets stijler.</description><dc:creator>4ourty2</dc:creator>
			<category></category>
			<comments>https://tommasso.tweakblogs.net/blog/7003/post-0x00.html#r_94456#reacties</comments>
			<guid isPermaLink="false">https://tommasso.tweakblogs.net/blog/7003#r_94456</guid>
			<pubDate>Tue, 23 Aug 2011 18:51:09 GMT</pubDate>
		</item>
		<item>
			<title>Post 0x00</title>
			<link>https://tommasso.tweakblogs.net/blog/7003/post-0x00.html#r_94455</link>
			<description>Hmm, iets met wiel en uitvinden. Maar je moet even weten waar je zoal op zoeken moet. Ik noem bijvoorbeeld:

http://ondra.zizka.cz/str...-isometric-libraries.texy

En op Wikipedia, wat algemener:

http://en.wikipedia.org/wiki/Isometric_projection</description><dc:creator>Sgreehder</dc:creator>
			<category></category>
			<comments>https://tommasso.tweakblogs.net/blog/7003/post-0x00.html#r_94455#reacties</comments>
			<guid isPermaLink="false">https://tommasso.tweakblogs.net/blog/7003#r_94455</guid>
			<pubDate>Tue, 23 Aug 2011 18:47:35 GMT</pubDate>
		</item>
		<item>
			<title>Post 0x00</title>
			<link>https://tommasso.tweakblogs.net/blog/7003/post-0x00.html#r_94453</link>
			<description>Ik zou eens kijken naar wat SDL te bieden heeft. Portable, hw accelerated en optimaal voor low level gfx operaties 
Oh en SDL heeft OpenGL bindings.</description><dc:creator>CopperCAT</dc:creator>
			<category></category>
			<comments>https://tommasso.tweakblogs.net/blog/7003/post-0x00.html#r_94453#reacties</comments>
			<guid isPermaLink="false">https://tommasso.tweakblogs.net/blog/7003#r_94453</guid>
			<pubDate>Tue, 23 Aug 2011 18:27:39 GMT</pubDate>
		</item>
		<item>
			<title>Post 0x00</title>
			<link>https://tommasso.tweakblogs.net/blog/7003/post-0x00.html#r_94450</link>
			<description>Als je toch de wondere wereld van OpenGL in durft te duiken kan ik Swiftless zijn blog zeker aanraden. Met minimale C/C++ ervaring heb ik zo stap voor stap aardig wat gigantische heightmaps op mijn scherm weten te toveren bij verbazingwekkend nette frama-rates.

Ik ben nu weer begonnen bij het begin omdat ik merkte dat mijn programmeerkunsten op een wel heel gammele fundering gebouwd waren (en omdat mijn projectsmap op een Vertex 2 stond zonder backup   ), maar ik had al een aardig opzetje voor een terrain generator voor hexagonale tiles zoals in Civilization 5.

Het reverse engineeren lijkt je in ieder geval goed af te gaan! Dit lijkt me in ieder geval ook een leuk opstapje voor de beginnende hobby-ist programmeur.</description><dc:creator>TeXiCiTy</dc:creator>
			<category></category>
			<comments>https://tommasso.tweakblogs.net/blog/7003/post-0x00.html#r_94450#reacties</comments>
			<guid isPermaLink="false">https://tommasso.tweakblogs.net/blog/7003#r_94450</guid>
			<pubDate>Tue, 23 Aug 2011 17:47:12 GMT</pubDate>
		</item>
		<item>
			<title>Post 0x00</title>
			<link>https://tommasso.tweakblogs.net/blog/7003/post-0x00.html#r_94449</link>
			<description>Heel leuk om te lezen! Typisch van die dingetjes die ik ook leuk vind om uit te zoeken  Ga je er nog mee verder? Zou het overigens leuk vinden om de source te zien hoor  Pastebin is daar inderdaad goed geschikt voor, mocht je het willen laten zien.

Verder is het zoals hierboven beschreven zeker interessant om eens te kijken naar het inzetten van een browser; allerlei zaken als transparantie e.d. worden een stuk eenvoudiger (png) en je kan het eventueel ook nog interactief maken.</description><dc:creator>Ram0n</dc:creator>
			<category></category>
			<comments>https://tommasso.tweakblogs.net/blog/7003/post-0x00.html#r_94449#reacties</comments>
			<guid isPermaLink="false">https://tommasso.tweakblogs.net/blog/7003#r_94449</guid>
			<pubDate>Tue, 23 Aug 2011 17:40:31 GMT</pubDate>
		</item>
		<item>
			<title>Post 0x00</title>
			<link>https://tommasso.tweakblogs.net/blog/7003/post-0x00.html#r_94447</link>
			<description>Ah, de klassieke isometrische tile-based engine. Altijd leuk om mee te beginnen als je games wil leren maken. Mijn complimenten voor deze eerste versie! Het is je gelukt om tot dusver het formaat en de rendering uit te pluizen en dat stukje oplossingsgericht denken is van groot belang als je dit een paar stappen verder wil zetten.

Allereerst, er zullen genoeg mensen zijn die je gaan vertellen dat dit niet in PHP moet. Deze mensen hebben uiteraard gelijk als je dit product voor een gameontwikkelaar aan het maken bent die daar z&#039;n geld mee moet verdienen. Voor de hobbysfeer brengt het echter wel een hoop nieuwe uitdagingen met zich mee die met een beetje creativiteit goed op te lossen zijn.

Om in het PHP straatje te blijven zal ik hieronder een scenario schetsen waarbij je PHP kan blijven gebruiken en toch een paar stappen extra kunt zetten.

Het grootste probleem met het gebruik van PHP zit &#039;m mijns inziens niet in de rendersnelheid, want deze is met wat out-of-the-box denken wel effectief &quot;op te lossen&quot;, maar eerder in het feit dat PHP niet gemaakt is om iets anders dan tekst te outputten (al dan niet interactief). Natuurlijk bestaan er wel initiatieven om GUI applicaties te maken in PHP, maar deze zijn niet geschikt om een game in te renderen.

PHP is voor low-level functies geen snelheidsmonster zoals je al weet. Vooral de pixelbewerkingen doen je de das om. Waar een gecompiled C++ programma moeiteloos met weinig CPU opcodes door een array van pixels loopt, heeft PHP last van de enorme overhead die nodig is om de taal goed te laten werken. Voor elke pixelbewerking worden in PHP talloze zaken gecheckt (opzoeken van de array key in de interne hash, moet ik de waarde typecasten?, etc..). Wil je snelheid in PHP, dan is het zaak om zoveel mogelijk high-level functies en extensies te gebruiken. Op het gebied van graphics zijn er een paar extensies als GD en ImageMagick. Deze zijn echter voornamelijk gemaakt voor manipulatie van images en niet zozeer om in een game engine te gebruiken.

Om het GUI probleem op te lossen kun je mijns inziens het beste zo dicht mogelijk bij de sterke punten van PHP blijven. Een mogelijkheid is om de webbrowser in te zetten als GUI. Hierin is grafisch veel mogelijk en de laatste jaren is er qua grafische snelheid het een en ander gebeurd (denk aan WebgGL, Canvas, HTML5) waardoor je met een beetje creativiteit hele mooie dingen kunt doen.

Het probleem van het trage renderen is een ander verhaal. Aangezien je isometric tiles gebruikt, kun je deze &quot;pre-renderen&quot; en opslaan als PNG bestanden. Je gebruikt nu bij het renderen de kleine tiles, zeg maar de kleinste eenheid in je terrein. Als je 5x5 van die tiles in een ruitvorm bijelkaar neemt en rendert tot een kant en klare grotere tile, dan kun je die kant en klare tile zonder pixelbewerkingen gebruiken. Het enige wat je dient te weten is de X en Y positie van de tile in je terrein.

Door de kant en klare tiles als het ware te &quot;cachen&quot; als kant en klaar PNG plaatje en klaar te zetten voor de webbrowser, kun je deze in een webapplicatie gebruiken. Nu is het alleen nog zaak om alles slim aan elkaar te knopen. De PHP code kent de layout van de tiles en HTML + JavaScript zorgt ervoor dat de tiles correct in de browser worden gerendered. Dit concept is niet nieuw, een goed voorbeeld is bijvoorbeeld Google Maps. Door slim gebruik te maken van uitwisseling tussen de backend en de frontend (AJAX JSON calls, COMET, etc,,,) zorg je ervoor dat de gebruiker één interactieve applicatie voor z&#039;n neus heeft.

Als het terrein vervolgens goed gerendered wordt, kun je eventueel met sprites gaan werken die je op het terrein rendert. Dat kunnen huisjes zijn of mannetjes die rondlopen. De enige beperking hierin is je eigen fantasie. In HTML5 kun je zelfs met audio en toetsenbord input werken om zo een wat &quot;completere&quot; spelervaring te creëren.

Als het basisconcept eenmaal staat kun je met talloze variaties aan de slag. Je kunt bijvoorbeeld de terrein tiles pre-renderen op verschillende groottes, zodat de gebruiker het terrein kan zoomen. Als de gebruiker het speelveld wil roteren kun je ook van elke tile 4 aangezichten renderen.

De &quot;maar&quot; met bovenstaand scenario is wel dat slechts een gedeelte van je code in PHP geschreven kan worden. De interactieve elementen zullen toch echt in JavaScript gemaakt moeten worden. Ik denk echter dat het behoorlijk haalbaar is om iets moois in elkaar te zetten. Het zal nooit zo soepel en snel zijn als een native DirectX of OpenGL applicatie, maar het sluit denk ik wel veel meer aan bij je ervaring als webontwikkelaar.

Veel succes verder!</description><dc:creator>DexterDee</dc:creator>
			<category></category>
			<comments>https://tommasso.tweakblogs.net/blog/7003/post-0x00.html#r_94447#reacties</comments>
			<guid isPermaLink="false">https://tommasso.tweakblogs.net/blog/7003#r_94447</guid>
			<pubDate>Tue, 23 Aug 2011 17:21:08 GMT</pubDate>
		</item>
		<item>
			<title>Post 0x00</title>
			<link>https://tommasso.tweakblogs.net/blog/7003/post-0x00.html#r_94445</link>
			<description>Volgens mij kan je heel simpel mbv XNA DirectX gebruiken is dit een optie?</description><dc:creator>Voxyn</dc:creator>
			<category></category>
			<comments>https://tommasso.tweakblogs.net/blog/7003/post-0x00.html#r_94445#reacties</comments>
			<guid isPermaLink="false">https://tommasso.tweakblogs.net/blog/7003#r_94445</guid>
			<pubDate>Tue, 23 Aug 2011 16:51:14 GMT</pubDate>
		</item>
		<item>
			<title>Post 0x00</title>
			<link>https://tommasso.tweakblogs.net/blog/7003/post-0x00.html#r_94444</link>
			<description>lol wat een leuke puzzel. Ga er maar aanstaan.... Succes, hoop dat het je lukt.</description><dc:creator>Mar2zz</dc:creator>
			<category></category>
			<comments>https://tommasso.tweakblogs.net/blog/7003/post-0x00.html#r_94444#reacties</comments>
			<guid isPermaLink="false">https://tommasso.tweakblogs.net/blog/7003#r_94444</guid>
			<pubDate>Tue, 23 Aug 2011 16:50:58 GMT</pubDate>
		</item>
	</channel>
</rss>