        hi everyone !!!

        this is my entry for the 256 bytes digger - compo.


instructions:

        * type in DIGGER and hit RETURN ;)
        * use cursor keys to move smiley digger.
        * hit any other key to quit

        * i used the german charset, so this could
          be a reason for strange screen output.
          (yeah i know, the screen does even look strange
          with the german charset) :)


restrictions due to size limit:

        * only one level :(
        * only one tiny level (16*8 'tiles') :(
        * rocks cannot be 'pushed' :(
        * there isn't even a score-counter :(
          (i had one but it sucked.)
        * there is really nothing to do except walking around and
          colleting diamonds. the program doesn't even know the
          difference between mud and gems :(
        * not much fun while playing :(
        * even less fun while playing again ;)


restrictions due to lack of size-optimizing-ability:

        * uhm... all of the above ?


the good things about it:

        * if you are good in coding assembly: much fun while
          looking at the sourcecode :)
        * it is really small and it won't even take a second
          to delete it from your harddrive
        * even though it took me an incredible long time to
          produce this little mess (about 24 hrs - no joke !!), 
          it was really fun and i learned quite a bit about code
          optimization...
        * at least i didn't spend ALL of my hollydays drinking
          beer. i really could have been drinkin a lot of beer
          the other night when i did that 10 hrs coding session...
          HEY wait a minute... why haven't i done THAT ???


some details about the creation of this program:

        * coded in 8086-assemly using A86. i also thought of using
          NASM (some 386/486 instructions could have been useful).
        * the first version of the prog was about 390 bytes large
          and didn't even check for falling rocks yet.
        * the real breakthrough came when i reorganized the prog's
          structure - 319 bytes. another re-organization brought
          it down to 275 bytes, the rest was more or less step by step
          (or byte by byte) using the usual tricks (word reg. inc/dec,
          xchg ax,xx etc.) and some serious analysing of what was
          really going on inside the registers.
        * it ran perfectly on my 486 but did not work on my family's
          P133. i found out that calling int 10H left different values
          in ax on both systems. 
        * fixing the bug described above, i did some re-organizing and
          the program shrinked to 250 bytes. i sacrificed the 6 bytes
          for 'nicer' screen output (fill the screen with red chars).

        well, i guess that's it. i'm really looking forward to see what you
        people will come up with. i know that there is much cooler stuff
        possible ;)

        christian henz (chrhenz@aol.com)

