|
Post by Tom Maneiro on Mar 26, 2005 10:21:24 GMT -5
>1. Easier GUI You mean: a wizard? I don't think so... it seems very easy for me, although the icons could be bigger and more descriptive
>2. Quicker Accses to SGTD/Emulator/ImaGenisis SGTD and Emulator are already in the toolbar! Just don't forget to set their paths in Options dialog. As for ImaGenesis... add that to the wishlist
>3. SEGA CD FMV\SGA movies Already in the wishlist!
>4. An Animated Sprite Code using LOADTILE. Hmmm... you have propsprite, movesprite and such things. Just read the docs!
>5. Save Capability (PEEK&POKE) for SCD Hmmm.... seems difficult, since there are litte info about how to save to RAM carts/internal SCD BRAM
>6. A Tool for SCD Conversion What do you mean with that? A Region converter?
>7. No Stinkin mscomctl v0.2x will not need it anymore, as reported on official sources.
|
|
oompa loompa
I AM THE GOVERNATOR
"Git 'Er Dun!"
Posts: 1,301
|
Post by oompa loompa on Apr 1, 2005 22:44:12 GMT -5
bah, not even gonna reply to this one cause suggestions are suggestions, they're people's opinions on what can be done to better the future of basiegaxorz, and isn't really asking for a reply =P
only thing i wanted to say that for "An Animated Sprite Code using LOADTILE.", animations can only be done in software, and i think it's best that the programmer program their own animations handler rather than relying on the compiler to make it for them. if animations were supported by hardware, then that'd be a horse of a different color
|
|
|
Post by Tulio Adriano on Apr 11, 2005 13:07:25 GMT -5
Hey there are ages that I am to post this: I miss the boolean operator NOT. it would be nice if it could be implemented.
|
|
oompa loompa
I AM THE GOVERNATOR
"Git 'Er Dun!"
Posts: 1,301
|
Post by oompa loompa on Apr 14, 2005 22:40:56 GMT -5
i could never get the NOT operator to become an operator like [and] or [or] or [xor] =P. Instead, i had to make it into a function. there are bugs, like this:
if not(joypad().0) then
the not function returns the compliment of whatever's in the arguments. if joypad().0 is 0 (false), the compliment of that number would be 65535 (true). if joypad().0 is 1 (true), the compliment of that number would be 65534 (true), so it would always return true x.x. i might need to change the function
|
|
|
Post by Walker7 on Jun 17, 2006 18:15:03 GMT -5
I love to use BasiEgaXorz! ;D
Here are some of my suggestions for future versions:
I realize that most bitwise operators are not there. There is the logical AND, OR, and XOR, but how about a bitwise version of those operators! They will have the same notation as in C++, that is, & for AND, | for OR, and ^ for XOR.
Here's another possibility: The Component function! It simply gives the Red, Green, or Blue value of a color. The syntax is:
Component <Pallette>, <Entry>, <Color>
Where <Palette> ranges fro 0-3, <Entry> ranges from 0-15, and <Color> ranges from 0-2. If the value is 0, the red value is returned, 1 returns the green value, and 2 returns the blue value, all returning values from 0 to 7.
Here's another idea: The FullPallette function. It simply loads 64 colors into the CRAM. Here's an example:
FullPallette xxx would be the same as Pallettes xxx, 0, 0, 64.
And here's another possibility: The BlankPallette function. It simply resets all the pallette entries to black (&h0000).
Here's another possibility: How about a Swap function? What would happen is it would swap two values. The syntax would be:
Swap <Argument 1>, <Argument 2>
The arguments must be variables. Then, a simple XOR-swapping algorithm is used. In C++, the algorithm might look like this:
x ^= y; y ^= x; x ^= y;
For example:
Swap a, b
If a was 2 and b was 7, then after the above statement is executed, a is 7 and b is 2. It's that simple!
Here's another one: How about using a C++-style syntax to do math? This is just for typing simplicity. For example, x += 2 would be the same as x = x + 2. The operators are:
+=, -=, *=, /=, %=, <<=, >>=, &=, |=, ^=
What about a conditional operator, similar to that of C++? The syntax would be this:
y = (x > 3) ? 5 : 7
This would function like this piece of code:
If x > 3 then y = 5 else y = 7 end if
How about this: A DrawTiles2 function, which works like the DrawTiles function, except it uses 16-bit (2 byte) values instead of single byte values?
I'll be coming up with more ideas later. Until then, take care!
|
|
|
Post by GiGaBiTe on Jun 26, 2006 3:43:34 GMT -5
The Sega CD's drive spins at 1x, and has a read rate of 150KB/s. You could probably get away with playing a 320x224 or smaller MPEG1 movie, but it couldn't be very long or very big. Programming for the SegaCD is a nightmare, mosly because you need to sync the two 68000's and that's a task of epic proportions in and of itself. Devster, you should use notepad++ as the code editor as it already supports basic (and more than 20 other languages) highlighting, and it's opensourced under the GPL. It's also fairly easy to add new highlighting to the editor, and the interface looks really clean and straightforward. notepad-plus.sourceforge.net/uk/site.htm
|
|
oompa loompa
I AM THE GOVERNATOR
"Git 'Er Dun!"
Posts: 1,301
|
Post by oompa loompa on Sept 23, 2006 0:57:14 GMT -5
the logical operators perform the same function as the bitwise operators of AND, OR, and XOR. eg: doing SOMETIHNG = (1=1 [AND] 2=2) will generate a value of 1. PRINT 1 [AND] 3 will generate 1 i can't remember whether 0 is a true value (for use in IF...THEN statement), or anything other than 0 is true. i think in the latest version of the compiler doesn't require the user to put in brackets outside of OR AND XOR (much more convenient ). i don't think i can use &, |, and ^ symbols because they might stand for some other operators already, but i'll see later
|
|
|
Post by Tom Maneiro on Sept 23, 2006 10:09:28 GMT -5
In BASIC (at least in VB and BEX), "&" is used to concatenate strings. The other two are not used at all...
|
|
|
Post by walker7 on Mar 22, 2008 23:53:19 GMT -5
I have really enjoyed using BasiEgaXorz over the past 4 years, and here are some more suggestions:
Simplification of the base code:
There are some things that can obviously be simplified in the base code that BasiEgaXorz outputs at the beginning (which is 0x002C16 bytes). Here are some examples:
[font=courier new]move.l #$8F02,($C00004) move.l #$491E0003,($C00004) move.w #'L',($C00000) move.w #'o',($C00000) move.w #'a',($C00000) move.w #'d',($C00000) move.w #'i',($C00000) move.w #'n',($C00000) move.w #'g',($C00000) move.w #'.',($C00000) move.w #'.',($C00000) move.w #'!',($C00000)[/font] ...can be simplified to...
[font=courier new]move.l #$C00004,a0 lea -4(a0),a1 move.w #$8F02,(a0) move.l #$491E0003,(a0) move.w #'L',(a1) move.w #'o',(a1) move.w #'a',(a1) move.w #'d',(a1) move.w #'i',(a1) move.w #'n',(a1) move.w #'g',(a1) move.w #'.',(a1) move.w #'.',(a1) move.w #'!',(a1)[/font] Basically, any time you use the same value or address more than once in a routine, you can put it into a register.
[font=courier new]; Wait Main Acknowledge wait_main: cmp.b #'Q',(SCOMMR) bne wait_main move.b #'Q',(SCOMMW) bra command_wait[/font] ...becomes...
[font=courier new]; Wait Main Acknowledge wait_main: moveq #'Q',d0 cmp.b d0,(SCOMMR) bne wait_main move.b d0,(SCOMMW) bra command_wait[/font]
[font=courier new]_vdp_init: lea $C00000,a0 lea $C00004,a1 lea $C00008,a2 _l0: move.b (a2),d0 cmpi.b #$00,d0 bne.s _l0[/font] ...becomes...
[font=courier new]_vdp_init: lea $C00000,a0 lea 4(a0),a1 lea 8(a0),a2 _l0: move.b (a2),d0 bne.s _l0[/font]
Anywhere you have the CLR.L instruction in a "d" register, you can replace it with MOVEQ #0, which is faster.
Maybe you could make it so that if some sections of the base code are not necessary, you can omit them from that program (e.g. if you do not have a "Print" command in your program, you could omit all the print-related routines and subroutines, such as "print_c", "print_z", etc.).
|
|
|
Post by walker7 on May 14, 2009 14:52:40 GMT -5
These are things you can do whenever you put "Asm" and "End Asm":
You could have a heading for each section of your code, as a colorful bar of any design, color, and font with the name of the section in huge letters.
One improvement could be using those expand/collapse [+] or [-] lists (like in your Internet history, for example) so that you can categorize your subroutines by section (indicated by the colorful bars with large font mentioned above), data structures, and/or other things and you don't have to look for all through your code to see where a specific subroutine or data structure is located.
Example for a set of math subroutines:
[-] Multiply_32 [-] Divide_32 [-] Multiply_64 [-] Divide_64
Then, you would click on one of those [-] signs to change it to a [+] and expand (show the subroutine), or a [+] to a [-] and collapse (hide the subroutine from view).
You could also make it so that you could color code using colors from the Sega Genesis color palette (R, G, and B all multiples of 32), so that you can make parts of multi-part subroutines stand out. You could put horizontal lines of any and all kinds between those parts--thin, thick, double, white, black, colored, etc.
You can put a note section after the label and before the code of each subroutine or data structure, with things like Input, Output, Flags, Error, Modifies, Logic, Register Usage, Notes, and Example(s). Here, you are given the option to switch registers on and off from the list at will. This will not affect the code, it is just for convenience.
To bring up the list, either right-click or double click. A box will be brought up, with the name of the subroutine, which can be changed, and each of the nine categories mentioned above. They are in the form of check boxes, and then, for each of Input, Output, Error, Modifies, and Register Usage that is checked, a row of 16 check boxes for it will appear below. These boxes represent registers d0-d7 and a0-a7 from left to right. Any boxes checked will appear in the corresponding lists.
In the Input and Output categories, after the register, you can put something like ".b", ".w", ".l", or anything else, like, for example, ".3-0", which means bits 3-0 of that register (the least significant nybble). ".B" is the same as ".7-0", ".w" is the same as ".15-0", and ".l" is ".31-0". If nothing follows the register name, it is assumed to be ".l". For example, the input for a Multiply subroutine might be: d0 = Multiplicand 1 d1 = Multiplicand 2 When there is more than one register, the = signs following each register are aligned. You can color each line of Input, Output, Error, and Modifies, if you want, as mentioned above. If anything is in RAM, you could write "In RAM:" instead of a register, and then what it is.
In Register Usage, you can state the category of usage. For example: a0 = POINTER: Whatever it's used for. There are several categories: POINTER: Used for registers a0-a7. For registers d0-d7, there are the following categories: ACCUMULATOR LOOP COUNTER COUNTER TEMPORARY CONSTANT There may be more, but those are the ones I know of for now. When there is more than one ACCUMULATOR, LOOP COUNTER, or COUNTER, they are numbered like "#1", "#2", etc.
Commenting can be enhanced by making an option to Align Comments, where for each subroutine, data structure, or anything else, all the ";" characters will be aligned for you, instead of doing all the tabs or spaces yourself. You set this differently for each piece of code.
Another thing would be to implement actual sets of graphics (just like ImaGenesis), and you can make them 1-bit, 2-bit, 3-bit, 4-bit, or variable length encoding. In variable length encoding, you might do something like this: Transparent = 0, Red = 10, Blue = 11. It appears in the form of a binary tree when you choose the lengths. You can choose to show the graphics, data, or both. You can give colors to each pixel, but that is just for show.
The graphics appear just like they do in Tile Layer Pro, and can be edited as 8x8, 8x16, 16x16, 16x32, 32x32, etc.; basically any size you want. You also have the option to transpose the rows and columns, for sprite usage. You can draw pixels, erase pixels, flood fill, swap colors, replace colors, draw lines, etc. There is also the option to order the tiles for sprites (transposing the rows and columns of tiles for each sprite).
You can also put palettes inside the ROM, appearing as rows of squares/rectangles in colors. You specify the number of colors you want, then put the colors. For example, dc.w $EEE,$00E,$E00 would appear as dc.w $EEE,$00E,$E00 with each color value appearing in a rectangle of the corresponding colors. There is an option to change palette length.
|
|
|
Post by Tom Maneiro on May 16, 2009 20:44:14 GMT -5
One improvement could be using those expand/collapse [+] or [-] lists (like in your Internet history, for example) so that you can categorize your subroutines by section (indicated by the colorful bars with large font mentioned above), data structures, and/or other things and you don't have to look for all through your code to see where a specific subroutine or data structure is located. Example for a set of math subroutines: [-] Multiply_32 [-] Divide_32 [-] Multiply_64 [-] Divide_64 Then, you would click on one of those [-] signs to change it to a [+] and expand (show the subroutine), or a [+] to a [-] and collapse (hide the subroutine from view). Bah, we just need a commandline BEX compiler! This way, i could use the great IDE features of, let's say, NetBeans ("code folding" is the proper name for the feature that you and (now) me wants), and plug-in our own BEX compiler there... I think that it's time to get rid of VB and move the compiler (and the IDE) to the big leagues NetBeans + BEX (+ el-cheapo gigs of RAM + flashcart?) = KICK ASS GENESIS DEVELOPMENT
|
|
|
Post by walker7 on May 17, 2009 10:58:30 GMT -5
Notice I said that these are things you can do whenever you put "Asm" and "End Asm" in your code (i.e. switching to assembly mode). You can program in Assembly, Basic, or a mixture of the two. You could also choose to build your ROM from scratch (i.e. without the code that BASIC automatically adds at the beginning).
All the things I mentioned earlier can be part of the toolbar at the top, grouped together: - Code in sections for Folding using [+] and [-] icons by each piece of code
- Colored Code and/or comments, and lines of all kinds between code.
- Note sections for each piece of code after the label and before the code
- Align comments
- A Tile-Layer-Pro-like interface for designing graphics, as well as choosing how many bits each pixel has or using variable-length encoding
- Implementing actual palettes in the code
More things might be that could make your own 0x200 byte header. The first 0x100 bytes is the vector table, and you could set some of the vectors yourself (e.g. HBLANK, VBLANK, DIVIDE BY ZERO, TRAP ERRORS, LINE 1010 EMULATOR, LINE 1111 EMULATOR, etc.), one per line for a total of 64 lines. You could double-click on a line and a dialog box will come up where you can use a scroll box or letter keys to choose a label, or just type in an address yourself. Of course, if you type in an odd address, it automatically clears the least significant bit, making it even (i.e. a logical AND with 0xFFFFFE). The rest of the header can be implemented using a gray dialog box.
You can choose whether word- or long-sized values are stored as big- or little-endian, with the default being big-endian.
You can declare a section to be a Subroutine List, a Data List, or just simple code. In subroutine lists, whenever you put a subroutine that does not affect the Status Register (SR), but stated to not modify any registers other than the Output registers, it can automatically put this for you, for example: [font=courier new] move.w sr,-(a7) ; Save SR. movem.l d1-d3,-(a7) ; Save Registers. ;----------------------------------------------------------------------------- (your code here) ;----------------------------------------------------------------------------- movem.l (a7)+,d1-d3 ; Restore Registers. move.w (a7)+,sr ; Restore SR. rts[/font] The lines that you see above are the way I usually code my subroutines. Of course, the ";" comment symbols (not counting the ones in the horizontal lines) for that subroutine are aligned if you choose to do so. Basically, whenever your type a ";" comment symbol, it automatically puts spaces up to the chosen point, then puts the comment symbol. There is a way to determine which registers to push w/the MOVEM.L instruction: If any instruction writes to or changes the value of a register (e.g. MOVE, MOVEQ, ADDQ, SUBQ, LSL, LSR, MULU, DIVU, MULS, DIVS, AND OR, EOR, NOT, etc.) but that register is not part of the Output or Modifies list, it goes in the MOVEM.L instructions as you see above. This option can be toggled, and it can be called "Sub-Register Save," and it is used for each subroutine you put in a [+]/[-] list. If you were going to affect the SR, you might put this: [font=courier new] movem.l d2-d7,-(a7) ; Save Registers. move.w sr,d4 ; Save SR. and.b #~%01110,d4 ; SR bits affected by this subroutine. ;----------------------------------------------------------------------------- (your code here) ;----------------------------------------------------------------------------- move.w d4,sr ; Update SR. movem.l (a7)+,d2-d7 ; Restore Registers. rts[/font] There would be an "SR affected" option in the subroutine. If you set it, choose which register from d0-d7 to put the SR in, and it will automatically appear as above (in the example above, register d4). Notice that when the SR should be affected, the registers are pushed first, and the SR goes into a register, whereas if the SR is not affected, the SR is pushed first, and then the registers. Of course, you can have the option to change which registers are to be saved, using a row of 16 check boxes, or just let it automatically calculate those registers. Of course, you could also have the option to take out the register-saving code, as well, but you can put it back if you want, with a check box.
When putting lines between pieces of code, you can determine the thickness and color. The thickness goes by pixels, with a maximum of 24 pixels, and they do not have to be in multiples of 8 pixels thick. "Thin" lines default to 2 pixels, and "thick" lines default to 8 pixels. Another thing that hey can be single, double, triple, or any design you want. The default color is black, but you can make it any color you want to, using either the Genesis palette (512 colors) or a True-Color (16,777,216 colors) palette, inputting the RGB values. You can also make different custom designs, as well, and save them, using a Tile-Layer-Pro-interface, just like tiles. For example, using an 8x8 tile to repeat over and over in the line will cause it to be 8 pixels thick. The thickness is how many pixels down you chose. Lines can be short or long. "Long" lines span 80 columns worth of text in the fixed-width font, and "short" lines can be anything you want, less than 80 columns.
When you edit tiles for sprites, you can still choose how many columns and rows you want, and the limit is four tiles in each direction (the 16 possible sprite sizes). Of course, they are stored in the correct tile order, which is the tiles from top-to-bottom, then left-to-right. You can choose whether to use the tiles for sprites or not.
When you do a subroutine, of course, the basic information ( Input, Output, Flags, which registers) is turned on and off with check boxes, and the rest you type yourself, like, for example, in a Divide subroutine, the Input is checked, and registers d0 and d1 are checked. You are given the "d0 = " part by the check boxes, then you would type "Dividend". The "d1 = " part is given, then you type "Divisor". You can also color them, like for example, the Dividend line blue, and the divisor part red. You can also put tables in these subroutine headers, as well. Another thing is that you can color and/or number each subroutine in the folding list. For example, you might make it like this: 1 [-] Multiply_32 2 [-] Divide_32 3 [-] Multiply_64 4 [-] Divide_64The [-]/[+] symbols would not be colored. If you decide to re-order your subroutines, you can do so, and their starting addresses and numbers will change accordingly. There is no limit as to how many subroutines you can put. The same thing goes with any other kind of data structure, like tiles, palettes, or anything else you can think of.
For those big, thick header bars, of course, you can choose the color, design, and font, and even make your own designs and fonts, as well.
Just typing code as-is will not have any effect on it, except for colors, etc. that you apply yourself, and it will compile as normal.
When you are editing tiles, you can check the "color count" over a single tile, several tiles, or many tiles. It displays how many pixels there are of each of the 16 possible colors. You can also draw pixels, erase pixels, draw lines, squares, and circles, flood-fill, replace colors, swap colors, and permute colors (rearrange their order). When you permute colors, there are two rows of colors on a dialog box. The first row is the original order, labeled 0-F. To swap two colors, click on any box on the second row, then click the one you want to swap it with. The colors and numbers on the second row will swap. Say the order is this: 0123456789ABCDEF 0623457189ABCDEF If you chose that order, pixels whose color value was 0x1 would change to 0x6. 0x6 becomes 0x7 and 0x7 becomes 0x1. For each set of tiles you create, you give it a label. It will appear as a label, then the graphics as tiles. Click on that set of tiles to edit them. The tile editor is in a dialog box. Palettes appear as a label, followed by a series of squares or rectangles in the colors with the color code (e.g. a gray square might display 888) inside them. Both these and tilesets can be commented.
Another important thing could be a "code tester," where you could choose to start at a certain point in the code, and test it to see if it works properly. It is in the form of a dialog box, with 16 boxes for each register, a code display window, RAM, the SR, the stack and its pointer. The code display window highlights which instruction is being executed. You can choose to start an an address of your choice or a label. If you choose it to start at a label, and you made it a subroutine, the register boxes that correspond to the Input will be colored instead of white. You can choose what colors to use, and you can edit the numbers inside the registers, which are in hexadecimal, and 32-bit.
Whenever you put a subroutine list, a graphic list, or a palette list, you can opt for it to show the addresses or not. Addresses can be put in subroutine headings, and could automatically be updated.
Another thing would be to have a VRAM address calculator.
|
|
|
Post by jlf65 on May 18, 2009 16:19:47 GMT -5
Bah, we just need a commandline BEX compiler! This way, i could use the great IDE features of, let's say, NetBeans ("code folding" is the proper name for the feature that you and (now) me wants), and plug-in our own BEX compiler there... I think that it's time to get rid of VB and move the compiler (and the IDE) to the big leagues NetBeans + BEX (+ el-cheapo gigs of RAM + flashcart?) = KICK ASS GENESIS DEVELOPMENT My thoughts exactly! Plain ANSI C command line tools that you can then use with any IDE on any platform. Personally, I'd use it with Geany on linux. I know people who would use Eclipse. The main thing is to avoid that dreadful Windows-only IDE. ;D
|
|
|
Post by walker7 on Aug 29, 2009 2:23:39 GMT -5
Here's another idea: A "RAM Mapper." This one can be used for an entire program to easily show how the bytes of RAM are used. It can be used in comments in subroutines, entire programs, etc. An example for a Tetris game might look like this: ( 1* 2) $0030-$0031: Lines ( 1* 4) $0032-$0035: Score ( 1* 2) $0036-$0037: Level ( 1* 2) $0038-$0039: Current Piece ( 1* 1) $003A: Block X Offset ( 1* 1) $003B: Block Y Offset ( 1* 1) $003C: Frames Left Before Piece Falls ( 1* 1) $003D: Piece Falling Interval ( 7* 2) $003E-$004B: Statistics (200* 2) $004C-$01DB: Playfield ( 1* 1) $01DC: Joypad - Held ( 1* 1) $01DD: Joypad - Pressed
In this case, the relative game data starts at $FF0030 in RAM. In the case of the Sega Genesis, since RAM only runs from $FF0000-$FFFFFF, you could just simply use the last two bytes to show the address (e.g. for address $FF0030, you could just put $0030). The RAM Addresses can be displayed in one of three ways: - Relative Format: You would state the base address just before the data and adjust how many nybbles are shown (the default is 4 nybbles, but you can put from 1 to 6).
- Abbreviated Format: Put the last 4 nybbles.
- Absolute Format: Put the entire address.
Here's the above example in each format: Relative Format (in this case, 4 nybbles shown): Base RAM Address: $FF0030 ( 1* 2) $0000-$0001: Lines ( 1* 4) $0002-$0005: Score ( 1* 2) $0006-$0007: Level ( 1* 2) $0008-$0009: Current Piece ( 1* 1) $000A: Block X Offset ( 1* 1) $000B: Block Y Offset ( 1* 1) $000C: Frames Left Before Piece Falls ( 1* 1) $000D: Piece Falling Interval ( 7* 2) $000E-$001B: Statistics (200* 2) $001C-$01AB: Playfield ( 1* 1) $01AC: Joypad - Held ( 1* 1) $01AD: Joypad - Pressed
Abbreviated Format (again, 4 nybbles shown): ( 1* 2) $0030-$0031: Lines ( 1* 4) $0032-$0035: Score ( 1* 2) $0036-$0037: Level ( 1* 2) $0038-$0039: Current Piece ( 1* 1) $003A: Block X Offset ( 1* 1) $003B: Block Y Offset ( 1* 1) $003C: Frames Left Before Piece Falls ( 1* 1) $003D: Piece Falling Interval ( 7* 2) $003E-$004B: Statistics (200* 2) $004C-$01DB: Playfield ( 1* 1) $01DC: Joypad - Held ( 1* 1) $01DD: Joypad - Pressed
(This is the one shown at the beginning of this post.) Absolute Format: ( 1* 2) $FF0030-$FF0031: Lines ( 1* 4) $FF0032-$FF0035: Score ( 1* 2) $FF0036-$FF0037: Level ( 1* 2) $FF0038-$FF0039: Current Piece ( 1* 1) $FF003A: Block X Offset ( 1* 1) $FF003B: Block Y Offset ( 1* 1) $FF003C: Frames Left Before Piece Falls ( 1* 1) $FF003D: Piece Falling Interval ( 7* 2) $FF003E-$FF004B: Statistics (200* 2) $FF004C-$FF01DB: Playfield ( 1* 1) $FF01DC: Joypad - Held ( 1* 1) $FF01DD: Joypad - Pressed
Here is an example of how each line is read, in this case using Absolute Format: ( 1* 2) $FF0030-$FF0031: LinesThis means that there is 1 entry that is 2 bytes long, runs from $FF0030-$FF0031 in RAM, and is used for the number of lines cleared. The first part tells the array size and element size; another example would be (50* 8), which indicates an array containing 50 items, and each item takes up 8 bytes of RAM. That is then followed by the RAM Address, either absolute, relative, or abbreviated, and after that, is its usage. This would be a pretty cool feature to implement. You can add new lines, and have the formatting typed in for you, you can color the lines to illustrate the different categories of RAM usage, you can delete lines, and you can swap the positions of lines, as if you wanted to rearrange the data. Any time you add, delete, or move lines, the array size, the data size, and the usage stay the same, but the RAM addresses are recalculated. Another thing, in the array and data sizes, the ones (units) digits of each dimension are always right-aligned, as shown in the examples above. This would be quite an interesting feature and a great way to keep your RAM maps organized!
|
|
|
Post by walker7 on Sept 3, 2009 6:17:20 GMT -5
How about an option to print your BasiEgaXorz programs? It will print in a fixed width font. You can choose to print it in color or black & white. With the colorful formatting that I have come up with, you can print the background as well (of course, this is optional), along with the bars that separate each of the program's sections that I described in a previous post (this is optional as well). Another thing, because these programs are so long, when you click File --> Print, it will tell you how many pages there are to be printed in that program. You can print the whole thing, print a range of pages, and do a print preview, just like Microsoft Word allows you to do.
|
|