============================================================================
; Zelda 86 by the Assembly Coder's Zenith
; The Eye Of Ganon
; http://www.acz.org/
;
; Programmer: David Phillips <david@acz.org>
; Graphics:   Brett Barwick
;             Dave Sheltema
; Maps:       Jeremy Goetsch <jeremy@acz.org>
;             Matt Johnson   <matt2000@dogtech.com>
;
; Started:     December ??, 1998
; Last Update: November 05, 2000
============================================================================


===== Intro ================================================================

This is it, finally.  The first and probably last release of Zelda 86.  It
has been a long journey, but I decided to finally end it.  For anyone who
hasn't played Zelda on one of the Nintendo systems, I highly suggest that
you do so.  Zelda is a game where you play a kid/guy named Link, walk
around, kill monsters, collect items, and save the princess or the world
or something.  I actually don't think I ever beat a Zelda game.  I almost
finished Zelda II for the NES about ten years ago, but never made it through
the last castle.  I started making this game for something to do, and
because a lot of other people like Zelda, not because I myself am a die-hard
Zelda fan.  Kind of odd, isn't it?

Zelda actually started over two years ago.  Macross Software had some
screenshots of a very nice looking Zelda for the 85 on their website, and
everyone in ACZ thought it was cool and we had a big debate over whether
or not we should do a version of Zelda.  We finally decided that there were
plenty of other games to make, and that we should do something else.  Later,
I was talking to a friend at school and decided that I should make a version
of Zelda similiar to the original for the NES over winter break (which being
was high school, was only two weeks).  I had a basic version with scrolling
screens done at the end, but it was only black and white.

ACZ had been having some discussions about creating a general grayscale
scrolling engine called ATOM (Advanced Tile Object Manipulator), so I
rewrote what I had started to be in grayscale, and tried to make as many
of the routines general as possible.  This is usually agood idea anyway,
but the idea was that the engine would be usable for other games.  Needless
to say, the game looked much better in grayscale.

Since Zelda was just a project for me for fun during the second semester of
my senior year of high school, it didn't ever have a goal or story.  I just
kept adding things, and Brett and Dave worked on maps and graphics.  We
never really added a story or progressive plot.  There was a planned story,
hence the name Eye of Gannon, but that was never added.  Later, Jeremy
took over doing the maps, and redid most of the original maps and added
some very nice map sprites.  Matt added some maps and other stuff later,
and wrote a very nice Windows map editor.

The project stopped in June, soon after I gratuated, due to lack of
interest on my part, and because I had a full time job that made me not
want to code in my free time.  The project has sat on my hard drive all this
time, not getting worked on at all.  I asked around, but never found anyone
who wanted to take it over or create maps for it.  Today, after some
prodding from Matt on the assembly-86 list, I decided that today would be
the day I finally somewhat finalize the maps and release the project.

The game is far from finished, so it would be more of a demo than a game.
I never wanted to release a demo, yet another unfinished program.  There are
far too many games like that already.  However, the goal of that thinking
was more to motivate me to finish than to keep me from releasing it.  I do
think that it is better to release it than to just have it get deleted
sometime down the road, as so many other great projects I have seen.  Much
of the best stuff for the 86 has never been released, and it is kind of a
shame.  The graphics in this are fabulous, and not drawn by me, so I would
feel bad if people did not get to see them.

The goal of this was to create the best game ever for the TI-86, and many
people seem to think that the goal was reached.  I wanted to show what the
86 is possible of, given time and effort.  The gameplay is similiar to that
of the Game Boy version of Zelda, although that is not the original goal.
I wanted to create a long adventure, but the engine design is not the best,
and there is no more room left to add more enemies and bosses.  The current
number of maps could be doubled, however.  Maybe this will inspire some
programmers or designers, and show what the calc can really do.


===== Playing ==============================================================

To play, you will need to send the three files to your calculator:

zelda.86p    -- the main program
zeldadat.86s -- the graphics and other data
maps.86s     -- the maps

Run zelda either with the Asm( command, or from a shell.  Do not use an
old shell that does automatic write back (does anyone even remember these?),
or the program may become corrupted.  Also, do not compress the main program
using Lite86, because the program writes back part of itself to save the
game.  I apologize for the large size of the program and data, but due to
the complexity of everything, I never added compression.  I think this is
the largest TI-86 program to date.


===== Keys =================================================================

arrows = move Link in 8 directions
+/-    = adjust contrast
more   = options
          2nd  = select item/weapon
          more/exit = back out
2nd    = swing/charge sword (if found)
alpha  = use selected item/weapon
exit   = save and quit


===== Source Code ==========================================================

The source code for this program is not included in the zip file due to it
being very large.  It is freely available, and released under the GPL.  See
copying.txt for more information.

I believe that the source code requires the latest version of Assembly
Studio 8x 4.0, which at the time of this release has not been officially
released.  There is a project file included with the source to be used with
Assembly Studio 8x.  zeldadat.86s must be compiled first, and a symbol table
needs to be generated for it.  Then, the zelda.86p can be compiled.

The original map editor, ZEdit, is included with the source code.  It is
written in C, and compiled with Watcom C/C++ 10.6 for 16-bit DOS.  It should
run fine under real DOS and Windows 95/98/NT4/2000.  It might compile under
another DOS C Compiler, but I doubt that.  I had originally thought that it
was portable, but later found out that I made many assumptions and the code
is not very portable at all.  For one thing, characters are assumed to be
unsigned, which I believe is against ANSI standard (or at least most C
compilers).

Matt Johnson wrote a very nice Windows editor, but at the time of the
release there were a few minor bugs, so I am not including it with this.
He may release it to the public at a future date.

If you which to create maps, I highly recommend reading zedit.txt, which is
included with the source.  Making maps requires understand how the game
engine works.  Reading that file should give you a pretty good
understanding of it all.  Remember that bad data WILL crash the game.  You
have been warned.  I recommend testing on VTI while making maps, especially
when just starting.  Maps are complicated, and keeping track of them all in
your head will be difficult, so it is recommended that you draw the layout
of the maps on paper as well as possible before starting to make maps.

The map sprites that the editor uses are extracted from zeldadat.86s. You
will need to recompile this anytime you change map sprites for the changes
to appear in the editor.  The easiest way to do this is to load the project
file into Assembly Studio 8x and use the project build function.

The engine seems simple, but you can do very complex things involving map
edges, warps and chests, so use your imagination.  The water temple is a
good example of this.  If you can't figure out how something works, take a
look at pre-existing maps and see how it is done.  There is only one thing
in the game that is a hack (a hard coded corelation with a map), and that
is where you get the shield in the first house.  The person is actually a
chest, and the code utilizes the change list structure to move the person
from in front of the door to a different location in the room.  There is
nothing wrong with hacks like this, but remember that most common things
can be done without actually specifically hard coding them.


===== Thanks / Greets ======================================================

A lot of people have played this during it's development, and have given
me numerous suggestions.  I hate to start listing people, because I know
I will leave off a least a few important names.  Anyway, you know who
you all are :)  Thanks for the help.

Greetings go out to the ACZ team and everyone else who is or has been
involved with the whole TI calculator programming scene.  I have learned
a lot from everyone, and probably wouldn't be where I was today if I hadn't
started programming TI calcs in high school.  Good luck to everyone in the
future!
