Leaderboard

This thread is closed for now, due to Curt's passing and time for some grievance has passed. Marty, feel free to start a new thread, when pieces of the puzzle fall into place.

Wondered where Mr. Do went after finishing the last level? Found him on an airport in Greece...;)

Badge please! this was my 50th attempt, give or take.

Another authorized conversion to the TI-99/4A of programs appearing within COMPUTE! Magazine, from Volume 8, Number 12, Issue 79, December 1986, Pp. 44-52. This game appeared after COMPUTE! Magazine dropped support for the TI-99/4A. From the article: Details on the TI-99 conversions The very original version of "Laser Strike" for the TI-99 was written in 1988 as a wholly original work of BASIC code, using only the description of play from the article rather than translations of other BASIC versions. A re-write of the game was required before it was considered finished. As well, two different computer logic routines were written, requiring two different programs due to TI BASIC memory limitations. This release was almost 100% re-worked in TIdBiT using only minor parts of the original, and processed from TIdBiT into BASIC listing and TIFILES for download using the tidbit99.com site. As with other versions in the article, the Commodore 64 version game play was used as the basis of the conversion. This first post contains the program listing as it might have appeared in the magazine back in 1986. A later post will contain the TIdBiT source, the programs in TIFILES format, in a cassette tape audio wav, as well as a disk image. Playing on the TI-99/4A In the TI versions, player one uses the left-side keyboard arrow keys, ESDX and Q for fire, or the left (number one) joystick. Player two uses the right-side keyboard unmarked arrow keys, IJKM and Y for fire, or the right (number two) joystick. To use joysticks, the ALPHA LOCK key on the TI-99/4A should be in the up position. The space bar acts as fire for either player, except when playing on a TI-99/4. When deploying ships, a marker will appear on the board: a white dot for TI BASIC and a purple marker for TI Extended BASIC. Fire marks the spot to deploy with an "X" or a "+" depending upon which BASIC version, then the player will select right or down. If the player marks a spot for deployment by mistake, a second press of the fire button will deselect it. The familiar TI "accept" beep tone will be sounded at the end of each player's deployment phase. The first beep indicates player one has finished and must now look away from the screen while player two deploys ships. The second beep indicates player two has finished and now the contest will commence. Note that computer player deployments are only hidden if playing against a human. This allows computer vs. computer match observers to know the locations of each computer player's ships. While playing, the marker for positioning the player's laser will appear in the same form as during deployment. At the end of a match, players may select to end game play or start again with new players. At the end of a computer vs. computer match, the computer players will wait several seconds before demanding a rematch. The game may be stopped during play using CLEAR (FCTN-4 on the /4A or SHIFT-C on the /4) in TI BASIC. In Extended BASIC, the game cannot be stopped but must be exited using QUIT (FCTN-= or SHIFT-Q on the /4A and /4, respectively.) How the computer plays The computer player uses fairly simple logic. It employs no strategy for ship layouts, instead placing them in random locations with random directions. While searching for a ship, it chooses randomly but spaces shots based upon the shortest remaining intact ship. Thus, if the explorer remains hidden, shots are spaced two grid positions apart. If the fighter is the smallest intact ship, then shots are spaced three grid positions apart, and so on. The computer logic is smart enough to determine if the smallest intact ship will fit in the space around a random firing solution. Once a ship is found, the area around the first spot hit is considered by excluding the layout of the ship which cannot hold its full length. If neither horizontal nor vertical layout can be excluded, then the computer will pick around the hit at random. Once it determines the layout of the ship, it will continue to follow until the ship is destroyed or it reaches the end of the ship, at which point it will reverse its search to work toward the other end. If another ship is discovered during the search for the second part of the ship, the longest of the two ships found will be focused upon, then once destroyed the smaller ship will be pursued. The computer is not, however, smart enough to make a shot which would intersect a ship's multiple layout possibilities. For instance, if a section of grid could hold a fighter in a "T" shape, that is three spots across and two down from the middle, but the horizontal positioning of the random firing solution puts the shot at the upper-right of the "T", the computer will not adjust the shot to the middle-top in order to exclude both layout possibilities. Instead, this area will be cleared by two shots. Envision this placement scenario as below. An "X" marks already hit or missed position, an underscore marks an open position, the asterisk marks where the shot is placed, and the octothorpe marks the ideal position for the shot. X X X X X X X X X X X X X X X X _ _ _ X X _ _ * X X _ # _ X X X _ X X X X _ X X X X _ X X X X _ X X X X _ X X X X _ X X X X X X X X X X X X X X X X X Features of the TI conversions The currently-active grid is "lit up" in white, while the inactive grid is dimmed in grey. This may not show up well on some monitors. Nonetheless, the current player is indicated in both name and by the location of the cursor. Parts of hit ships will not fade. Player names are limited to eight characters in TI BASIC, and may contain upper-case letters and numbers. Names longer than eight characters will be truncated. This helps cut the amount of time needed to display the current player's name in the message area at the top of the screen. In TI Extended BASIC, player names may be 13 characters of upper-case letters, only. The TI BASIC version puts a white dot on top of ships which have already been hit. As the cursor is active in two modes, one in which the ship underneath needs to be exposed and the other hidden, among other factors, each movement of the cursor requires lengthy calculations. This makes movement lag a little, but it adds a "neat" factor of a sprite-like cursor as opposed to simply skipping an exposed area during movement. TI Extended BASIC special provisions The TI Extended BASIC version with the 32k expansion attached makes use of sound lists to enhance game sounds. To do this, the characters "0" through "8" (ASCII 48 through 56) are "loaded" with the sound lists by way of the CHAR subprogram. This is also why numbers are prohibited from a player's name. The console ISR (interrupt service routine) is notified of the location of the list and then instructed to play it. One of the benefits of interrupt-driven sound is the BASIC interpreter may continue processing. However, in most cases, the game will issue a call to the SOUND subprogram in a way which halts the program until the list has completed. This pause works due to how TI BASIC and Extended BASIC play sounds from the SOUND subprogram. The interpreter creates a sound list from the SOUND subprogram parameters, then sets it to play by the ISR. By this method, you will likely have noticed how a program will continue while a sound of up to 4.25 seconds plays unless the program executes another call to the SOUND subprogram. See the BASIC or Extended BASIC manual for more details on how sounds with a positive or negative duration work. The maximum duration of 4.25 seconds is based upon the highest value for the duration byte in a sound list, >FF or 255, divided by the number of times the ISR executes in one second, which is 60 for an NTSC machine. To wit, 255 ÷ 60 = 4.25. See the Editor/Assembler manual for more information on sound lists. Some lessons to take away from this program TI BASIC has a limited amount of memory to store both its program and run-time variables. The original version of "Laser Strike" exceeded BASIC's memory. It was re-written in an attempt to be more code-efficient and removed some superfluousness. 30 years later, this re-working restored some functionality to the game, including a marquee title screen, as well as better computer player logic, and much better program code. Still lurking was the concern of running out of memory. It was concluded that reducing the number of variables in use would help with memory management. The first iteration of this approach was to use minimal utility and loop variables, and use the grid variable G(,,) 0-elements to hold game play information. However, this became cumbersome to track and inefficient to program. As well, it was determined that using two-letter descriptive arrays consumed less program space. For instance, SP(1) uses less space in program memory than G(0,1,1), especially when addressed multiple times. The uses of 0-elements were eliminated, and OPTION BASE 1 put in place to help spare memory, as well. Throughout the program, different approaches to grid coordinate addressing is used. In the main loop the R,C (row and column) method is used. In other parts X,Y addressing is used, and yet another section H,V (horizontal and vertical.) This can be confusing to follow, but fortunately only caused minor problems during development. While a uniform system should have been employed, it did work out as these disparities are isolated to specific sections and functionality. Initial test releases of this program severely abused variables, again in attempt to keep memory footprint low. Once feature-complete, BASIC still had a little over 2k of memory remaining. This is plenty for the purposes of this game so those variable abuses were eliminated. For instance, the "I" and "J" variables are used for flags and loop counters, but also held critical information during certain phases. Programming this way make it difficult to ensure important data are not overwritten by temporary values. They were replaced with "L", for ship length, and "T", for type of ship in focus, to make the program code easier to follow. The TIdBiT source has some comments on how programming the game was approached, as well as some details on a couple of neat tricks done to enhanced game play experience. "Laser Strike" for the TI-99/4A. Left, the computer plays a good game. Right, computer vs. computer comes down to the wire. Program 7: TI BASIC Program 8: TI Extended BASIC

It was a blast playing all three games last night on the ZPH stream. Here are the highest scores we got! We'll probably give Ms. Galactopus and Doggone It! another go before the end of the contest to see if we can improve our scores. ? - James Ms. Galactopus: ZeroPageHomebrew (James): 15755 ZeroPageHomebrew (Tanya): 10220 City Defence: ZeroPageHomebrew (James): 4947 ZeroPageHomebrew (Tanya): 781 Doggone It!: ZeroPageHomebrew (James): 32479 ZeroPageHomebrew (Tanya): 23275

Thought id have a run on City Defence tonight for kicks - not too bad - found myself panicking multiple time during the run and as a result many little mistakes 16,713

This is an excellent game!! Doggone it : 31,047

The latest demo build of E.X.O. is available directly on the rather excellent JS7800 https://raz0red.github.io/js7800/ This build is slightly different to the one from a few weeks ago (some palette fixes, a couple of points where the player deaths felt a bit cheap are revised and a few other general code tweaks). Plans for the next major version: Include level 2 (factory) Thinking about revising the title section and removing the instructions etc.. I don't like the text with the 8 wide font so maybe rethink this section Level select option - The game isn't totally linear. After level 1, select either level 2 or 3, but both need to be completed to open up level 4. Ability to save progress so you don't have to start at level 1 each time you play. Custom pause screen Balance and more tweaks to level 1

Doggone It!: 48,878 Improvement on my previous score, really addictive game.

I'll never forget it. Many many years ago I brought a girl home from the bar and in casual conversation said how she hated when guys didn't "trim downstairs" I started to panic a bit... When we got to my place I darted to the bathroom, grabbed my roommates beard trimmer and got to work... The next day I saw him trimming his beard with it...I didn't have the heart to tell him. Always keep your trimmer locked in your room!!

The San Leandro Computer Club started one up recently, but that's by private invitation only. Might be cool to do one for the general Atari crowd, but do we really want to see what each other look like? Could be scary .

Final entry for me. 49m on my Intellivision II with a different coax cable. No more video issues!

Only tested in Altirra but seems OK. Start to begin, * for number of players, # for difficulty. star_island.bin

I can't understand a word Enya sings but it is soothing.

We did a live stream of Wormhole 2000 yesterday, with an on the spot review. The three of us really found the game entertaining even though it is a bit rough around the corners. Only one of us actually owns a Jag, and I recommend this game for anyone who likes playing and collecting homebrew for the Jag, but you may want to hold off until it is being sold through AtariAge to get a complete package (game, box and manual). The actual gameplay starts around the 33 minute mark. We like giving the VLM some love before going to meat of the stream.

Battlestar Galactica: Frak Felgercarb Clockwork Orange: Yarbles Farscape: Frell Hitchhikers Guide Galaxy: Zark Judge Dredd: Bastich Mork: Shazbot Red Dwarf: Smeg Smurfs: Smurf Last one might present a smurfing legal challenge from the mother smurfing copyright owners.

I'm just sharing something that I'm studying, as I think I can find my issue by reading.. ---------------------------------------- AAAA M M SSSSS A A MM MM S A A M MM M S AAAAAA M M SSSS A A M M S A A M M S A A M M SSSSS ---------------------------------------- Programmer's Documentation Documention: 1/19/93 Joe Delekto Note: This documentation covers the 128k AMS system only. After the AEMS is released, documentation will be available. ---------------------------------------- The AMS expanded memory card is a unique piece of hardware, in that mapping is simple, and lends itself well to overlay-structured programming. Because of the AMS design, no memory manager is necessary. The card itself uses a 17 bit address bus (18 for 512k) in order to access the SRAM on the card. The upper 4 bits of a standard 16 bit address are used to select one of 16 mapper registers. The remaining 12 bits from the address bus are combined with 12 bits taken from the mapper register, in order to give a maximum address bus of 24 bits in width. This will allow for a maximum of 16MB to be accessed. (AEMS) On the 128k card, only the 5 least significant bits (6 for 512k) are used from the mapper register. The other pins from the mapper output are unconnected. "Mapping" is accomplished by changing the value in the mapper register, to point to one of 32 pages (64 on 512k). No reading/writing or any transfer of memory is involved with mapping. All that is changed is the pointer to the RAM chip on the address bus. Because of this, mapping can be done in a few clock cycles, using only a couple of instructions. Programs which take advantage of the AMS can be extremely large, with about no change in execution time. As with any memory expansion, there are limitations on overlay sizes. It is recommended for the AMS system, that the root segment of your program be placed in low memory. (>2000 - >3FFF) Code overlays, from 4k to 24k in size, (in 4k increments) can be mapped in within the upper 24k of memory. This means that an 8k root segment can call as many (up to 24k) overlays as necessary. The result is a HUGE program, with structure and modularity. (Most desired in the programming field!) This document will describe how mapping works, as well as the AMS resident library created by Art Green and myself. I will also go into some detail as to how you can use Charles Earl's Hot Bug debugger to debug AMS code. Before I get to the meat of this document, I would like to explain why we chose our method of memory expansion. We chose 4k pages for two reasons. First, it made the hardware design simple, and made utility routines short and fast. Second of all, since our system uses overlay methods, many 4k overlays can reside in memory at once. The overlays can be any size from 4k to 24k in length, falling on 4k page boundaries. The larger the overlay is, the less overlays you can have. You can have 4k, 8k, 12k, 16k, or 24k overlays, and overlay size determines how many overlays you can have. (i.e. Six 4k, three 8k, etc.) You are NOT required to use only one size of overlay. For instance, you could have one 12k overlay, and an 8k overlay, along with a 4k overlay. (24k total). Keep in mind that most subroutines fall well under 4k of space! This means that MANY subroutines can be placed within just one 4k overlay! We believe you will find this to be one of the most flexible memory expansion systems, ever to be designed for the TI-99/4A. Many interesting applications, besides large programs, can be developed. We are making all information on the use of the memory available, so that programmers can make full use of its abilities. ---------------------------------------- PART ONE: Map Modes and Registers ================================== Because the AMS has a 17 bit address bus, (18 for 512k) and the TI-99/4A only has a 16-bit address bus, the extra bit(s) need to come from somewhere. These extra bits are taken from the mapper registers. 4 bits are taken from the memory address on the 9900 bus, and used to select one of 16 mapper registers. The remaining 12 bits from the 9900 bus are combined with the 5 bits from the mapper register, to make a new bus with 17 bits. The actual paging process is done by changing the values in the mapper registers, to point to new pages in memory. Here is the address diagram: * From 9900 Address bus: >A000 |+-- || |+---> 12 MSB to 12 LSB of new address | +----> 4 MSB to mapper register select * From mapper 5 bit output forms 5 MSB of new address A15 - Mapper Register Select A14 - " " " " " " A13 - " " " " " " A12 - " " " " " " Mapper Address Bus A11 - MA11 A10 - MA10 A09 - MA09 A08 - MA08 A07 - MA07 A06 - MA06 A05 - MA05 A04 - MA04 A03 - MA03 A02 - MA02 A01 - MA01 A00 - MA00 * On Mapper Address bus: +---+ A15 -| M |- MA16 A14 -| a |- MA15 A13 -| p |- MA14 A12 -| p |- MA13 | e |- MA12 | r | +---+ Since only the >A000 - >F000 range inside memory is mapped, register >A through >F are used in the mapper. Note the mapper register number corresponds with the 4 MSB of the address being accessed. Once the mapper register is loaded with a page number, (5 bit address which forms 5 MSB on AMS bus) any read or write to the 4k block it corresponds to, will access that 4k memory page. For example: I load mapper register 10 (>A) with page number >15. Any time I read/write or access the >A000 block, I will be writing to the 4k page >15. If I were to load mapper register 10 with >15, then perform a CLR @>A02E, I will actually be writing (from the AMS address bus) the address: >0001502E. Notice how the page/offset are combined on the AMS bus to get a 17 bit address (show here as 32 bits for clarity). It will be worthwile to note, that even though the address was >A000, the >A had no influence whatsoever on the new address. The primary purpose of the >A was to select which mapper register the 5 bits will come from. The same holds true for the entire >A000 - >FFFF range. Because >A - >F are used to select the mapper registers, we have 6 registers to use, and 6 4k boundaries. To load consecutive addresses, just load the consecutive page numbers into the mapper registers. The AMS system works in two modes. map mode, and pass mode. Power-up places AMS into pass mode. When the mode is in pass, AMS acts as a plain 32k card, and the mapper passes actual addresses used to the AMS bus. (i.e. a CLR @>A000 will clear the memory location at >A000). There is no difference between pass mode, and standard 32k mode. The second mode is map mode. Map mode is the mode which uses the MSB of an address to select the mapper register, then dump the register's contents to the AMS bus. Note, when map mode is enabled, it would be a good idea to initialize the mapper registers to known values! The CRU address for AMS is >1E00. In order to use mapping, some CRU instructions are required to: 1) Switch AMS between map/pass modes, and 2) enable/disable register read/writes. Below is the code which changes map modes for AMS. LI R12,>1E00 * AMS CRU Address SBO 1 * Enable Mapping SBZ 1 * Disable Mapping This is the only code required to switch back between modes. Only 2 instructions are necessary. In order to access the mapper registers, CRU bit 0 must be set. When it is, DSR space is temporarily disable, so that writing in the >4000 space will set a map register. When CRU bit 0 is set to zero, original DSR space is recovered, with no side effects. It is recommended that you enable mapper registers, write their values, and then disable them immediately. The reason being that forgetting to disable the registers will keep you from accessing and DSR routines. To enable and disable registers, use the following code: LI R12,>1E00 * AMS CRU address SBO 0 * Enable Registers . . * Set registers here . SBZ 0 * Disable Registers In order to load a mapper register with a page number, all you need to do is write to the >4000 block. To determine which mapper register you wish to change, use the follow calculation: MRAD = 2 * Register# + >4000 So that to clear mapper register 10, you would use: 2 * >A + >4000 = >4014 CLR @>4014 * Clear Register 10 Note, you can also read from a mapper register, for the purpose of saving previous page values: SPAGE BSS 2 * Hold Page # EXMPL MOV @>4014,@SPAGE * Get MR10 CLR @>4014 * Clear MR10 . . . MOV @SPAGE,@>4014 * Restore Page RT Because writing to the mapper registers is just writing to an address, indirect addressing could be used as well. For example, Consider setting up the mapper so that when in map mode, addresses are the same as in pass mode. It is always a good idea to first set up the mapper registers, and then go into map mode. While in map mode, registers can be changed at will to point elsewhere. If your code to do mapping resides in upper memory, take care NOT to change the register where your code is executing. Pointing to some other place in memory will continue execution on the new page, causing undesired, or unknown results. It is possible though, to point to a new page where code is executing, provided that valid code exists at the current offset and new page. Below is an example which sets up the mapper registers as normal 32k pass mode, yet places the mapper into map mode. The registers can be changed later to access other pages of memory. PAGES DATA >0A00,>0B00,>0C00 DATA >0D00,>0E00,>0F00 START LI R12,>1E00 * AMS CRU LI R1,PAGES * Page Table LI R2,>4014 * Start at MR >A LI R3,6 * 6 Pages to set SBO 0 * Enable MR's RSET MOV *1+,*2+ * Write to MR DEC R3 * Dec counter JNE RSET * Continue SBZ 0 * Disable MR's SBO 1 * Enable map mode END IMPORTANT: Note that the 5 bit page value is placed in the most significant byte of the mapper register. Because only 5 bits are used in a map register, and because the 2 cycle read/write on the data bus loads the most significant byte last, the mapper is loaded with this value. Therefore, page >18 would be >1800, page >05 would be >0500, etc. It might be worthwhile that AEMS addresses page numbers normally, since 12 bits are used instead. ---------------------------------------- PART TWO: Overlay Techniques ============================ Because the AMS system is able to map overlays up to 24k in length, on 4k boundaries, it lends itself well to program development using overlays. First, a root segment is established, which will contain the code to call an overlay. The root segment must remain in memory (without using tricky code to map it out), and will contain the routine used to call an overlay subprogram. We recommend the following: 1) Place the root segment into low memory (8k). 2) Make all overlay calls BLWP routines. Below is the stub code for both the root segment overlay manager, which is used to handle the simulation of a BLWP vector for a mapped environment. **************************************** * Overlay Manager * Version 1.0 * R.A.Green OVMGR SBO 0 * Enable map regs MOV *R11+,R10 * Get N # pages MOV *R11+,R9 * Get 1st map reg MOV *R11+,R7 * Get 1st page # OMGR2 MOV R7,*R9+ * Set mapper reg AI 7,>0100 * Add 1 to page # DEC R10 * Loop for N pages JGT OMGR2 * Finish loop SBZ 0 * Disable map regs MOV *R11,*R11 * Get real BLWP vec MOV *R11+,R7 * Get WSP MOV *11,R9 * Get sub address MOV R13,@26(R7) * Simulate BLWP MOV R14,@28(R7) * MOV R15,@30(R7) * OMGRW EQU $-12 * OVMGR workspace LWPI 0 * R6,R7 user wrkspc B @0 * R8,R9 call sub BSS 2 * R10 BSS 2 * R11 DATA >1E00 * R12 AMS CRU addr BSS 6 * R13 - R15 **************************************** Below is the code which replaces the original BLWP call in the root segment. This is done for every subroutine that generates an overlay. * Overlay Call * Version 1.0 * R.A.Green * BLWP @OSUB OSUB DATA OMGRW * Manager WSP DATA $+2 * BL @OVMGR * Use overlay manager DATA N * # Pages in overlay DATA >40xx * 1st mapper reg addr DATA n * 1st page number DATA sub * REAL BLWP vector **************************************** In order to generate a call for an overlayed subroutine, the real BLWP call must be replaced by the OSUB information. Now, the overlay generator needs to know: 1) How many pages the overlay is. Remember that it can be 4k-24k in length, broken into 4k pages. The routine needs to know what mapper registers to start mapping the 'N' pages in at. The first page number the overlay resides on is also given, along with the ACTUAL BLWP vector address for the overlayed routine. To illustrate this, let us say our root segment is in the >2000 - >3FFF block. We have created an overlay, and inside the overlay is a routine called INPUT, for which the BLWP vector starts at >C2E0. The overlay is in page >18 of memory, and is only 4k, or 1 page in length. To call the overlay, we would use the following code: BLWP @OSUB1 * Call overlay stub DATA >0001 * 1 page long (4k block) DATA >4018 * >C000 block DATA >1800 * 1st page # (only one) DATA >C2E0 * BLWP Vector Note, it would be very useful to have a program loader to load segments of code into different pages. Although such a loader exists for AMS, it is only used for AMS files with special headers for overlay and root segments. A similair loader can be constructed, which loads the overlays into their corresponding pages. The overlay code examples above, are the code segments installed (automatically) by the linker. That eliminates the need for passing the arguments to the overlay generator, and keeping track of relative page addresses. You may however, choose your own method of overlaying. We made it very flexible to customize your software so you can choose how you want to map. Keep in mind that other programs may be resident to AMS, and using the linker/loader will ensure that AMS programs are page relocatable, and won't overwrite memory resident code. ---------------------------------------- PART THREE: Using Hot Bug with AMS ================================== Most often overlay programs are tedious to debug. If you have access to Charles Earl's Hot Bug debugger, I recommend you learn how to use it. It is by far one of the best debugging utilities available, and can certainly work well for debugging AMS programs. Since Hot Bug will also load program files, you can use the debugger to change the page map, and load in your overlay code! Hot Bug Command Summary ER - Edit Register EW - Edit Word DM - Display Memory SPC - Set Program Counter G - Go (# of steps) In order to access the registers, and check the code/data within pages, we need to enable both the mapper, and the registers. Choose a word of memory that does not have code to use the following commands: (For this example, I use >3FF0) 1: ER 12 1E00 2: EW 3FF0 1D00 3: EW 3FF2 1D01 4: SPC 3FF0 5: G 2 (1: Load Register 12 with CRU >1E00) (2: Put SBO 0 at 3FF0 Enable REGS ) (3: Put SBO 1 at 3FF2 MAP Mode ) (4: Set program counter to >3FF0 ) (5: Execute 2 instructions ) NOTE: If the mapper is in an unknown state, (register values unknown), you will want to set the registers before actually placing into map mode. Just use G 1 instead, edit the registers (see below) and then G 1 again to get into map mode. To read/write to the mapper registers, use the DM command to look at the >4000 block. Only addresses >4000 - >4020 are of interest to us. (Mapper regs 0 - 16). NOTE: Even though the upper 24k is mapped using mapper registers 10 - 16, the other mapper registers can be used for temporary storage. 1: DM 4000 (1: Display Memory at >4000) In order to change a register value, just use the EW command. For example, to load mapper register 11, (>B000 block) with page >15, use the following: 1: EW 4016 1500 (1: Load mapper register 11 with >15) Now let's try an experiment. What we will do is write the same page to 2 different mapper registers, and observe what happens. Use the following commands: 1: EW 4014 1500 2: EW 4016 1500 3: DM A000 (1: Load mapper register 10 with >15) (2: Load mapper register 11 with >15) (3: Display memory at >A000 ) Note what the data in memory is at >A000. Now, if you use DM B000, you should see the same data you saw before. Let's try something interesting. Use the following commands: 1: EW A000 FACE 2: DM B000 (1: Put value >FACE into >A000) (2: Display memory at >B000 ) When you use the DM B000, you should get a surprise. When you wrote to A000, you actually changed the word at B000, as well as A000. Why? Because both 4k block point to the same page! Perhaps now you can envision some of the interesting tricks you can accomplish with the AMS system. One such application is the arbitrary locating of data buffers! It is also possible to load a memory image file, on non-consecutive pages, and yet still load the mapper registers such that the program is contiguous in the upper 24k! If that's so, then it means we can load E/A option 5 program files anywhere inside AMS, and then just map in their pages to the proper blocks in high memory! In this manner, even code with absolute origins becomes page relocatable, at least for paging purposes. By placing page numbers into the registers, and using Hot Bug's LOAD command, you can load overlay image files. Keep track of the address for the BLWP vector in the overlay, as well as the page you LOAD it into, and how many pages it takes up. This information you will need to pass to the overlay generator in your program. See? Loading, debugging, and running overlay code on the AMS system is very feasible, and not difficult. ---------------------------------------- This concludes this section of programmer's documentation. The next document will focus on the memory resident utility routines, which AMS programmers can use in their software. Memory allocation, exit code, memory moves, and far VDP read/write routines are available. Also, AMS program have access to the E/A 5, and AMS Overlay program file loader. The loader will load either type of file. The exit routines for AMS have the option of keeping the programmer's code resident for instant execution when desired. We have worked very hard for the past couple of years, to make this memory expansion as user friendly as possible. We are, and will continue to supply support for the AMS card. Without the software support to use AMS, it would just be an expensive paperweight.

Yikes just getting on the board before time runs out. Got really busy with freelance work and my son's home schooling.

Nah, she's a hagly creature that would stab you in the eye for a dime bag, but I needs that sweet sweet nectar.

I just played this on my CC2 using the 7800_48K banking file with perfect harmony! This is an excellent start to what I foresee as a stellar Atari 7800 port of Popeye! I’m really impressed with the graphics and arcade likeness. Thank you @darryl1970 for crafting this excellent beta!

Got my pro controller today. Works great, especially with my new Wormhole 2000, too!

6084. I’ll take what I can get on this one.(disc speed)

Doggone It! - 37,749 Small improvement!

Ms. Galactopus (Updated ROM) - 19,020 Here's a new score without the glitch on the fixed ROM!

I should have read this earlier myself GDMike. I ended up re-inventing this after a quite a long road of trial and error. PAGES DATA >0A00,>0B00,>0C00 DATA >0D00,>0E00,>0F00 START LI R12,>1E00 * AMS CRU LI R1,PAGES * Page Table LI R2,>4014 * Start at MR >A LI R3,6 * 6 Pages to set SBO 0 * Enable MR's RSET MOV *1+,*2+ * Write to MR DEC R3 * Dec counter JNE RSET * Continue SBZ 0 * Disable MR's SBO 1 * Enable map mode END

Today is national video games day. Seems like every day is some kinda national day for something.

It is a common problem with devices which do not sync properly to the composite output of our classic machines. Stipulating the chipset of @jedimatt42's unit is the same as yours, I would speculate the console output is slightly out-of-spec due to the 10MHz crystal. I posted the link elsewhere to a blog entry where the author describes how the 10MHz crystal was out of spec enough to cause the color burst to look fine in an oscilloscope but cause the converter to only sample luminance.

Yes. Thanks for the report. There are three major opportunities for speedup which are yet to come.... 1) sort the moves - this will give maybe 5x speed 3) cull the moves - this will allow the search to be stopped at any time and still have a good move 4) search a subset of the moves after (1). Perhaps another 2x. I expect to be able to get the program roughly 10x faster -- in the long run.

Yeah, wasn't it something like the outcry he did in the 70s (which by the way gave us the very Silicon Valley that we have now... yeah, Atari did that) and so he graciously did not accept the award for something... was a while ago and it has been a long day. But anyhow, he was a visionary back then for sure, and it was a different time. The thing that blows my mind is that pot is more legal now than it has ever been, yet everyone is so uptight about being offended and taking things too far. Smoke a joint and lighten up, man. Just space out for a while, and it will all be groovy. I should get a hot tub. Where was I? Where am I?

I vow to not sleep until dirty Word Rockets is produced.

Star Strike update: 8,100 - Level 4, disc 7,290 - Level 5 bonus Must have pressed reset 150 times tonight! Ugh, so annoying. ?

Don't forget. It does nothing that a piece of hardware 1/4 the cost can't do. That's the measure of my useless purchases.

Playing Godzilla by B.O.C. while watching Godzilla on TV. Awesome. Annoying the wife while doing it. Priceless.

Doggone It!-47,981 50K is looking more and more possible, but phew. Top-notch stuff, I just want to keep playing this game, tho many attempts wind up "15 minutes of my life I want back" when it goes to poo, the "good ones" are rewarding as heck, feels exactly like a "good game" should make you feel.

I know this isn't 100% Atari 7800 related, but one of my projects is about to be picked up by a world wide distributor. Im starring in this comedy/ horror movie called "The Hike". The only reason I'm posting this here is b/c I want you to see the trailer... my character is rocking two outfits in this movie, and one of them includes the #1 coolest Atari t-shirt I have ever seen and Im a lucky man to own it. Even on the silver screen, I'll be pimping Atari, babies.

I bought this a couple of weeks ago and just got around to trying it out. I had been using my TI with a 10.1” security monitor because it had an AV input. That was good for testing, but kind of hard on my old eyes. Tonight I decided to try out the AV2VGA with an old VGA monitor. The first picture is from the security monitor, the others from the VGA monitor. Not a bad result for a device that cost less than fifteen dollars. The dark spot near the center is from the monitor.

As a fan of both Word Rockets and swearing, I second this.

A new release (v0.6.1) is now available with the following changes: Added new 7800basic keywords: drawhiscores (attract|single|player1|player2) (Karl G) and added code completion for item Updated hover tooltips for 7800basic keywords Fixed issue with batch file generating multiple terminal windows (Karl G) Added compiler files verification with anti-virus note and consolidated file list with file permission check (batari Basic and 7800basic) For those using the make/batching process I believe I have fixed the multiple terminal windows generating - the handle was not being disposed of (perhaps a recent change in VS Code). Also the very latest release 1.49 has added some additional functionality to the terminal window so I may now be able to do some additional things (we'll see). I've also added a file exists check for all compiler files for bB and 7800basic so this should now help highlight that some of these files are now unlawfully! captured by anti-virus software.

Using sandpaper would be asking the Fickle Finger of Fate to point in your general direction. Taking the console apart takes less than five minutes. CC

Would never work in this day and age my good man. Nobody will accept smoking doobies, and having hot chicks in hot tubs. Hot tubs melt snowflakes. It was only a few years back Nolan was being called out for "sexist" shit in the mid 70s.

I call it an absolute failure because at least to me, it's an absolutely redundant piece of hardware. There's nothing it does that I can't already do, which is the yardstick by which I buy new hardware.

The 128K 800XLF board -- I have one (it is discussed here on AA in another thread) and is marked 130XE on the PBI. I was a working with Curt on that a few years ago. The history of the PAL/NTSC 800XLF (not ROSE) was the last thing he and I were discussing which led to posting of those PDFs, there was more information he was going to dig up for me, but alas...

Anyone who says otherwise is just flat-out wrong. I always say now is the best time to be a gamer. We just keep adding to all that came before, including more ways to play all that came before. There are so many options it's mind boggling and you can never really run out of new things to explore, both past and present.

We (very fortunately) haven't lost a single order yet. There's been one or two which got stuck and then arrived after a significant delay, or were bounced back to our P.O. Box. - but they've all arrived eventually. However, yours is the first one heading to Moominvalley so I'm not sure what varieties of mischief could happen along the way. Rikki & Vikki runs entirely in Mode 320B, which is one of Maria's stock configurations. The differentiating factor is that it's the first released title on the hardware which separates Maria and Sally's paging through the use of a new mapper. This greatly simplifies resource management and allows for a much larger quantity of textures to be used onscreen, which is essential for the high resolution modes. It's comparable to what Nintendo was doing with the NES's MMC1, MMC3, etc. There's not too many "tricks" used, we had to ship by a certain day and this limited the amount of experimentation or crazy effects - I'd describe the visuals moreso as being careful with what we could afford. ...ah, and 33 Copies left.

I vote for Learning Fun 3 as a new BSR release. Include the following edutainment games. Classics: Math Master Factor Fun Word Rockets Word Hunt Crosswords Memory Fun All New Games: Word Rockets II: Now With Curse Words Sudoku Oregon Trail More?

To be more clear, if the fujinet is turned off and Atari is on, any SIO pin that goes high will back feed power (I measure ~1-1.5V) to the esp32. This causes noise to be sent over AUDIO_IN back to the Atari.

The carts themselves work fine on NTSC console, a Brazilian console will not work correctly on a NTSC tv.

Hijacking this thread back to myself, I will take the occasion of Keith Robinson's 65th birthday today to announce the next title from Blue Sky Rangers. Release date probably in November (I was kind of hoping to be able to hit the abandoned 10/10/20 Amico date, but it is not going to happen). I will announce a second title at that time.

I assume this is a Kieren-free book?