| |
Wednesday 21st
After a couple of days working on other projects, work
resumed on the Editor and saw me adding the relevant calls
to the "Undo Store" routine from the various tool routines.
It became apparent that the Pen and Brush routines needed a
little debounce code, mainly because every frame that the
mouse button is depressed is counted as a separate edit.
The debounce was relatively simple to write, however,
and merely involved incrementing a flag each frame if the
button is held, and calling the Undo Store routine if it
isn't - now the user can make huge swirling edits with the
Pen or Brush, but the Undo Store routine only kicks in when
the mouse button is released.
Continued with some housekeeping checks, specifically
to stop Brush mode being activated or Brushes being stored
if there is no Tileset assigned to the current Layer. Next
came the various Tile functions (Copy, Rotate, Clear, etc.),
which required a few little tweaks to ensure that empty
memory isn't being tinkered with.
Sunday 18th
Today was something of an anti-climax, blog-wise; after
about three or four solid days' work invested in the
Undo/Redo routine in the past, I managed to sit down and
code a new, working routine in the space of an hour! After
setting up the buffers and variables, it was merely a case
of tackling each bit of functionality in a methodical
fashion (I'm certain that looking at old notes or code would
have confused me further, and possibly why successful
results have eluded me in the past).
Flushed with this success - although extremely
sceptical that the routine works at all - I added some extra
variables to store the map number, as well as the cursor
positions - this way, when the user steps back with Undo,
they'll be returned to the relevant layer and screen
position.
Turned my attention to the Text Display routine, which
seems to flicker in different ways on different machines.
Although some chunks of text have flags attached to them (so
that the text is only updated if information changes), some
didn't, so a small amount of time was devoted to tidying up
the code and adding extra checks. The Editor looks exactly
the same on my Win2K setup, bt I shall be testing this
routine with interest on my laptop.
Next came a small toolbar tweak, with the addition of a
Show All option positioned between the Zoom Out and Zoom In
icons (something of an oversight, in retrospect).
Saturday 17th
After a couple of sessions with the tried and tested
pencil and paper, I already have a few routines plotted out
ready to be coded. The past couple of days have been spent
tinkering with Symmetry, as it's always been one of my
favourite features from Dpaint, and seemed fairly easy - in
theory! - to implement.
The first task was to set up some test code in my Pen
Mode routine, then convert this into a modular routine which
could be used by everything else. It took a little bit of
time to get my head around the X and Y Symmetry combined,
but after a couple of sessions the code was working
properly; all that remained was a few tweaks to the cursor
display routine.
Today was spent mostly debugging and testing, as the
Symmetry code was applied to as many tools as possible. I
also added key checks so that the X/Y lines (axis) can be
moved, added the X/Y lines to the MiniMap, and created a
Symmetry menu to house all of the various commands (and
allow the user to change the line colour).
The final task was to explore the possibility of
applying Symmetry to the Brush handling functions; after a
little tinkering, I managed to get some progress made, but
the sheer number of factors - handling point, rotation,
sizes - means that this task will probably wait until after
Beta.
Wednesday 14th
Started off today's session by tying up the loose ends
in the Project I/O system, writing the code to store the
Grab buffers and their thumbnails (as an afterthought, I
tweaked the code so that it generates the thumbnails rather
than store them - only a saving of 32k to the Project
filesize, but every little helps).
It made sense to tackle the New Project routine next,
as I'm knee-deep in initialisation code; again, this
entailed sifting through the variables and compiling a
routine to reset each and every relevant variable. Luckily,
this only took about an hour of furious typing, as I could
already count on a coupe of existing routines to initialise
all of the Map and Tile variables (the remaining
initialisations I merely copied 'n' pasted from the Load
Project routine).
Thankfully, my New Project window - which appears when
the Editor is first loaded - was coded in a way that allowed
me to integrate my variable reset routine quite easily; on
boot-up, the code sets up the environment accordingly; on
selecting New Project, it sets up the environment and resets
the relevant flags. Peachy. :)
Did a little housekeeping while I was tinkering with
the New Project code, and made sure that all popup windows
were deactivated properly (this entails freeing all of the
gadgets, buttons, and text labels to ensure that the system
resources are freed up properly).
Also took the liberty of updating my Splash Screen, and
added some Credits to the Help/About dialogue box. Next came
a tweak to the toolbar, as I wanted to add the Project
Load/Save icons and space things out a little.
With most of the major functionality now complete, I'm
finally starting to see the light at the end of the tunnel.
The following tasks remain in my way before Beta:
1. Undo & Redo - I currently have some scribbled notes and
flowcharts for this routine; the more I use the Editor, the
more I miss having the ability to quickly erase a mistake,
so this will be an essential addition.
2. Map Rotate - I have X/Y/Z flipping currently, but I want
to add the facility to flip the map 90 degrees in any
direction; currently my code for this flatly refuses to
work.
3. Tile Duplicates - The biggest problem with this routine
is how the data is presented to the user. It's an extremely
useful tool to have, however, so I shall be plotting this on
paper over the next couple of days.
4. Circle Draw - The current Circle routine is poor to say
the least; I need to get my head around the maths and get
the routine finished.
5. MiniMap Scrolling - There's a small bug in the MiniMap
routine which fails to update the scroll values when the
mouse is used to drag the MiniMap window. This, I predict,
will be a swine to debug.
6. Test Map - The bulk of the code for this is already in
place; I simply need to work on the scroll routine to make
it as user-friendly as possible.
Needless to say, if anyone out there has any
suggestions on the above tasks, I'd be glad to hear from
you!
Tuesday 13th
Kicked off today's session by tweaking the Zoom
function slightly; I figured it'd be nice to see the whole
map Zoomed out, not just the current layer, so I added the
option to Zoom Current, Zoom Visible, or Zoom All, for
maximum flexibility. The Editor chugs a little bit when all
8 layers are visible and zoomed out to their fullest, but as
it's intended as purely a visual aid rather than an editing
mode, I can live with a little slowdown.
After updating the Project I/O accordingly (every time
I add a significant variable I now have to adjust the
Project I/O code, which helps keep me organised!), I moved
on to a small problemette with the Animation routine, as
mentioned a couple of days ago.
Basically, each animation is independent of the
Tilesets that might be loaded. For instance, Animation 1
might choose to animate through a sequence of 5 tiles from
Tileset 3; Animation 2 might choose to cycle through some
frames from Tileset 1. Though this may seem slightly
unorthodox, it allows the artist to build up a library of
animations based on the current project (indeed, the whole
point of the Editor's current layout was to allow everything
to be contained in one easy-to-handle chunk). The programmer
can then take the animation data and use it accordingly;
after all, the Editor may recognise key variables, but in
the real world, certain attributes - such as the Tileset -
could be ignored.
After getting my head around this, I tweaked the
relevant controls and updated the Project I/O code (as well
as the standard Animation I/O code) accordingly. Then, I
tweaked the various tools and displays to ensure that only
animations which affect the currently selected Tileset are
displayed. It works beautifully, but I hope it all makes
sense to the end user.
Seeing as I was knee-deep in Tileset-related code, I
also took the bold step of changing how the Tileset
selection works; previously, pressing Tab would increase the
Tileset number and thus, change the Tileset for the current
Layer. However, this also meant that changing the Tileset in Anim or Grab mode also changed the Tileset for the map. With
the new system, the user has to press Ctrl+Tab in order to
assign the current Tileset to the current Layer (and thanks
to some obscure variable assignments tucked away in my Map
Display routine, this took far longer than it should!).
This had a knock-on effect that entailed changing any and every line of code that referenced the Tileset index value, replacing it with the value appropriate
to the current map. This was fraught with the potential for
screw-ups, but thankfully I managed to escape with just one
minor error (and it also allowed me to fix a bug in my
Invert Mask routine).
Next came a small change to the Dropper routine, which
not only grabs the tile under the cursor, but also now jumps
to the appropriate Tileset, too. The final task of the night
involved tracking down a couple of bugs in the MiniMap
routines, but thankfully these potentially big problems
turned out to be minor oversights.
The final task remaining, as far as Project I/O is
concerned, relates to the Grab Buffers and images; with this
code completed hopefully tomorrow, my To-Do list will comprise just a handful of
tasks (bugs and changes aside), and with this in mind I've
set myself a deadline of December 31st for the Beta date.
Rest assured, if things go badly over the next two weeks
I'll pop back and erase this paragraph. :)
Monday 12th
Added a couple of new functions to the Tiles menu; the
first, Tile Close, allows the user to clear the current
Tileset, leaving a "blank" slot (it only became apparent
that this was needed thanks to the addition of the Project
I/O code - since the Load Project code will load in every
defined Tileset, being able to eject a Tileset is useful if
it isn't required as part of the Project file).
Also started on the Change Tilesize function, which had
been on the back burner for a while, but again came into
play once the Project I/O was started (seeing as I'm already
writing small routines to initialise changes such as
Tilesize, I may as well use them throughout the Editor).
As an afterthought, I added the option to either clear
the existing Tilesets, or resize them; though this may
become an issue when moving from 16x16 tiles to 128x128
tiles, it does represent a nifty way of generating
thumbnails for larger Tilesets, but for the moment I'm not
convinced so I've popped this option on the To Do list.
The remainder of today's session was full of non-bugs,
those strange quirks which send you scouring old routines
for obscure bugs before you realise that the bug is caused
by a careless typing mistake. However, the bulk of the
Project I/O is now complete, and hopefully I'll be able to
finish it completely tomorrow.
Sunday 11th
Not much progress today, but I managed to continue with
the Project I/O and make a little more progress. Firstly, I
tackled a small bug in the Tabber initialisation code, which
was causing the wrong Tabber to be activated (this involved
popping the existing code into modular routines so that they
can be called by the control routine and the I/O code).
While checking other parts of the I/O routine, I
noticed that the Animation code fails to take into account
what Tileset the animation is supposed to use; I'm in two
minds whether or not to include this in the animation data,
but it was added to the To Do list nevertheless.
Friday 9th
After delving into the Tile and Buffer code last night,
I kicked off by adding the facility to erase a range of
tiles, as opposed to just the current tile - a rather handy
feature, and something which only took a couple of minutes
to write. Although I enjoy flashes of inspiration and adding
features, however, it's high-time I stopped having ideas and
finished my To-Do list. :)
As a result, I decided to tackle the Project I/O head-on, after
giving the approach some thought last night; the most
sensible method seemed to involve splitting the task into
chunks (Maps, Tilesets, Masks, etc.), in order to make sure
each part of the routine works properly before moving on to
the next.
In order to save time creating new dummy data each and
every time I added a new chunk of code, I hit upon the idea
of writing the Save code first - this way, I could load the
existing project data, tweak the options associated with the
new chunk of code, save using the updated routine, then
return to the code, add the load routine, and check that it
loads back in properly.
This enabled me to plough through the routine fairly
quickly, each code update adding more data to the project file, allowing me to ensure that every
element contained in the file could be checked at any and
every stage.
The beauty of sifting through every variable also has
the added bonus of giving the code an unintentional Spring
Clean; there are a few variables that weren't needed any
more, for example, a couple of routines which weren't
setting things up properly, and even a routine which was
still working on the assumption that there were only six Map
layers. By the end of the day, I had the bulk of the work
done, and already the Editor has become even more of a joy
to use. :)
Thursday 8th
Started off by stripping out the last few bits of code
I'd written last night (I wanted the Zoom system to use its
own canvas, but for some reason the code wouldn't co-operate
so I decided to do it the tried and tested way instead).
Next came the task of adding Zoom control to the two
buttons I'd already prepared on the Toolbar; this meant
encapsulating all of yesterday's (test) code into a small
function which could be called from either the menu or the
Toolbar.
At the same time, I also added a small check to prevent
the zoom initialisation form taking place if the Zoom level
is already at the one currently being selected, as well as a
small check to ensure that Zoom mode always returns to the
Layer that was previously being edited (this is because most
of the controls and drawing tools are disabled in Zoom mode,
though it's still possible to mess around with the Tabbers
and suchlike).
Next on the list was to tweak the Tile Panel so that
animating tiles are displayed properly (I'd forgotten to add
this to my ToDo list and thus, slipped through the net when
I was developing the animation system last week). I
considered adding an option to toggle this new function, but
due to the way the animation system works, I think it's
pretty important to see which tiles on the tileset have
animations assigned to them.
While tinkering with the Tile Panel, I noticed that I'd
neglected to add Tile Grab Mode to the toolbar; hastily
booted up PhotoShop and added an appropriate icon, then
added a few extra checks to the Toolbar routine. There,
nobody will ever notice. :)
In another shoddy attempt to avoid tackling the Project
I/O, I set up all of the necessary variables to keep track
of any edits made throughout the program; currently, each
Layer/Map has a small flag associated with it - whenever an
edit is made (e.g. drawing a line), the flag is set. Shoudl
the user then choose to exit the program, they are alerted
that there are unsaved changes (naturally, this flag is
cleared if the map/map set is saved).
Essentially, I'd like to expand this system so that any
changes, be they Tiles, Animations, Meta Data, Mask Data,
Brushes, or Grab Buffers, are automatically logged and the
user prompted on exit (or indeed, if they try to load a file
over the existing data).
Decided to bite the bull by the scruff of the horns and
do some more work on the Project I/O routines, which
involved tracing through each and every one of my variables
and working out which ones need to be loaded, cleared, or
initialised.
The final task of the night was the creation of the
Create Tileset function; while playing around with some of
the Grab functions, it occurred to me that, for the purpose
of grabbing tiles and quickly trying out ideas, it'd be
useful to be able to create a blank Tileset (rather than
import an existing one). Thankfully, this was
straightforward enough to write. :)
Wednesday 7th
Decided to kick off tonight's session by tackling the
Zoom function, something which I've tried to do on numerous
occasions. However, as is typical for programmers, the best
way of approaching the routine came to me while I was doing
something mundane, as opposed to thinking about the problem
in hand.
Essentially, all I need to do is shrink the tileset
when the zoom is initiated, and display the map using the
shrinky dinky tiles instead of the regular ones.
After a bit of furious typing, the code was working but
with unexpected results; I wrongly assumed that every
tileset would be the same dimension, so a couple of tweaks
later and everything was working propery. With that in
place, I also added the animation code to ensure that even
the Zoomed map will still animate.
This, rather handily, highlighted a couple of bugs in
the Animation routine which only showed themselves because
the Debugger was turned on (errors with Databanks rarely
crash the PC, but always show themselves in Debug mode).
With the bugs fixed, all that remained was to tweak the
control routines and map-boundary checks to ensure that the
Zoomed map can be scrolled safely. Amazing that a routine I
regarded as a huge task took merely a couple of hours to
implement. :)
Friday 2nd
Kicked off by adding the Tile Grab Mode option to the
Tools menu (while tinkering with the Editor last night, I
noticed I'd forgotten to include it). This also exposed a
small oversight in my Tool Tips routine (which meant that
tools selected from the menu didn't activate the relevant
Tool Tip). Needless to say, this was quickly rectified.
Next came a couple of tweaks to the animation code,
which I'd plotted out a couple of nights ago on paper. After
much tinkering, however, the code would still not work
properly... until it dawned on me that I was checking the
code by looking at the animation thumbnail preview which, for some
reason, was still using its own temporary piece of animation
code. D'oh!
That fixed, I tweaked the code so that all animations
are processed and not just the thumbnail preview; up until
now, the actual animations on the map and the thumbnail had
been animated separately, but this caused speed problems if
both were running at the same time (mainly due to speed and
delay values being decremented twice per frame).
With that out of the way, I made the final few changes
and modifications to the Ping-Pong code; the final tweak
came in the form of a couple of additions to the anim I/O,
seeing as I'd added flags for each animation to show the
animation direction in Ping-Pong mode. That done, the
animation system is now - touch wood and all extremities
crossed - completely finished. Yay, and indeed, woo.
Thursday 1st
Today's brief session saw me tying up the various
button controls for the numerous panels; now the user can
hold Shift while clicking on certain buttons to
increment/decrement the value by 10, as opposed to just 1.
Took this a step further and also added it to the
Nudge/Scroll tools on the Grab Panel, but increasing in
steps of 8 to keep it artist-friendly. ;)
Finished up by adding the tile animation code to the
Test Map module - and thanks to the fact that I tightened up
to map printing code into a single loop, it also means that
the Test Map module now displays and animates all 8 layers,
too (all at no extra charge).
|
|
