jacobus

HBO - Hamilton Burlington Oakville Atari Users Group (Ontario, Canada)

Seastalker is the easiest but it so simple (the game keeps offering help) that solving it does not feel satisfying at all. I would recommend either The Witness (murder mystery) or Hollywood Hijinx (fairly logical puzzle solving) Planetfall is a bit tougher, but a lot of fun!

It wasn't so much a matter of cheapness (the feelies were all included in the grey boxes) so much as outraged retailers who wanted smaller and more conventional packaging. Can you imagine trying to put the original StarCross saucer on a store shelf? Never mind the folios that either took up a massive amount of space when displayed face forward, or disappeared completely when shelved sideways.

I found it quite challenging! It's one of the only four Infocom games that can fit the entire program and data onto a single side of an Atari disk, so while the game is a bit short, the puzzles more than make up for it. Also, possibly the first of their games where the Feelies acted as copy protection - you will need the star map to progress past the first few moves. (feelies are also needed for Infidel - both at the beginning and throughout the game)

Zork I,II,III Deadline Starcross (with a friend - we spent an entire weekend hammering at it) The Witness (the first one I solved) Planetfall (my favourite - somewhere I have a printed walkthrough of the entire game) Enchanter, Sorcerer, Spellbreaker Infidel (a close second favourite) Seastalker The Hitchhiker's Guide to the Galaxy (with help (lots) from the Invisiclues) Cutthroats Hollywood Hijinx The Lurking Horror (on the ST) ...all back in the day I played RTZ to about the halfway point, but just couldn't finish - even getting that far was a grind I tried to interest my kids in playing - even the avid readers weren't interested. Has anyone's offspring enjoyed them?

I'm a little late to the party, but I highly recommend a language called "Quick" from Raindorf Software, now available from DGS. Basic-like syntax, compiles to fast machine code, gives you access to DLI, VBI, fine scrolling, etc. (Still a work in progress, but this game is written in Quick) ZombieAttack RC3.xex This DLI example makes the top part of the display appear to fade in by incrementally increasing the brightness of the first 8 scan lines INTER DLI1 ;pfield0 A LOCAL BYTE [ V0,V1,V2,V3 ] BEGIN PUSH SYNC(1) CHBAS=168 ;alt1 charset VSCROL=VFS ;set fs values for top *set starting colours V0=32 ;40 red-orange V1=160 ;168 blue grey V2=112 ;120 ultramarine V3=64 ;72 red *fade in REPEAT PFCOL0=V0 PFCOL1=V1 PFCOL2=V2 PFCOL3=V3 V0+ V1+ V2+ V3+ SYNC(1) UNTIL V0>=40 DLI(DLIFOUT) ;make next DLI active PULL ENDDLI

Would it be possible to daisy-chain multiple units instead? Could that be one of the expansion cards?

Nice setup Alfred! The amount of dust on that XL suggests it ran for a very long time without intervention. What was the name of your BBS? (I'm assuming it was local to the GTA) The Toronto Sun Sunshine girls - the first page of the newspaper anyone ever turned to :-)

and a few more... (all NTSC)

I'd be interested in the right cart version

Take care Jay and get well soon!

That is the first software collection I've ever seen that does not include any pirated items! Amazing! ?

Tried that ? It fails in the VBI.

Sure ? but it's in Quick so may not be much help. The PUSH/PULL, IPUSH/IPULL, ZPUSH/ZPULL (currently commented out) are supposed to be used to save and restore the CPU registers but the documentation is both confusing and contradictory and I have never quite figured out how to use them properly. Is this something I can add to the copy routine instead? INTER VERTBLNK LOCAL BYTE [ V ] WORD [ VD,VM OP=130,SP ] BEGIN * PUSH * IPUSH * ZPUSH * SP=OP IF VBENABLE=1 ZZC=0 REPEAT CALL($00,$00,$00,$4C00) ZZC+ UNTIL ZZC=33 VBENABLE=0 ENDIF *Horizontal Scrolling IF SCRLH=1 ;scroll right --> IF HFS=9 IF HCS<16 ;limit of screen IF MAPXR<65 HFS=12 HCS+ ENDIF ENDIF ELSE HFS- ENDIF ENDIF IF SCRLH=255 ;scroll left <-- IF HFS=12 IF HCS>0 IF MAPXL>0 HFS=9 HCS- ENDIF ENDIF ELSE HFS+ ENDIF ENDIF HSCR00=HCS HSCR01=HCS HSCR02=HCS HSCR03=HCS HSCR04=HCS HSCR05=HCS HSCR06=HCS HSCR07=HCS HSCR08=HCS HSCR09=HCS HSCR10=HCS HSCR11=HCS HSCR12=HCS HSCR13=HCS HSCR14=HCS HSCR15=HCS HSCR16=HCS *vertical scrolling IF SCRLV=1 ;top down (plyr moves up) IF VFS=0 IF VCS>0 IF MAPYT>0 VSCR00- VSCR01- VSCR02- VSCR03- VSCR04- VSCR05- VSCR06- VSCR07- VSCR08- VSCR09- VSCR10- VSCR11- VSCR12- VSCR13- VSCR14- VSCR15- VSCR16- VFS=7 VCS- ENDIF ENDIF ELSE VFS- ENDIF ENDIF IF SCRLV=255 ;bot up (plyr moves dn) IF VFS=7 IF VCS<16 IF MAPYB<64 VSCR00+ VSCR01+ VSCR02+ VSCR03+ VSCR04+ VSCR05+ VSCR06+ VSCR07+ VSCR08+ VSCR09+ VSCR10+ VSCR11+ VSCR12+ VSCR13+ VSCR14+ VSCR15+ VSCR16+ VFS=0 VCS+ ENDIF ENDIF ELSE VFS+ ENDIF ENDIF *handle joystick IF STICK0<>15 V=JOYX(STICK0) ;LUT ADD(PX,V,PX) SCRLH=0 ;no scroll flag IF PX<124 SUB(PX,V,PX) SCRLH=255 ;scroll left flag <-- ENDIF IF PX>125 SUB(PX,V,PX) SCRLH=1 ;scroll right flag --> ENDIF V=JOYY(STICK0) ;LUT ADD(PY,V,PY) SCRLV=0 IF PY<119 SUB(PY,V,PY) SCRLV=1 ENDIF IF PY>121 SUB(PY,V,PY) SCRLV=255 ENDIF ELSE SCRLH=0 SCRLV=0 ENDIF * OP=SP * PULL * IPULL * ZPULL ENDVBI

Thanks for all the help, I am definitely closer! The code (with some very minor changes) works when called from the main part of the program but fails when run in the VBI. I should elaborate - it runs properly once when called from the VBI but then locks up the computer. Do I need to do something different when exiting? .lsfirst zplocation .equ $CC ;; Uses memory locations starting at this address. org .equ $4C00 ;; Start of main code src .equ zplocation+$0 ;; Source dst .equ zplocation+$2 ;; Destination bytes .equ zplocation+$4 ;; Size .org org ; caller sets src & dst & bytes ; Y is size minus 1(!), maximum of 127 (i.e. 128 bytes) memcopy ; sta dst ; stx dst+1 ldy bytes loop lda (src),y sta (dst),y dey bpl loop rts .end

Thank you for this! Once I get the code working, I'll come back to this for now, I'll go with readability ?

Is there any significant difference between 800 motherboards? I have a revision 9 with white/light grey cartridge slots and a rev A with black ones...

When ? ?

Thank you very much for the reply! in answer tour questions: -I do not cross page bountries -zero page is not used as a source or destination -source and destination change each time the copy routine will be called -rather not have self-modifying code, I may put this in a cart -speed is my preference - I need to copy 56 bytes 32 times for a full screen redraw -when you say size - do you mean size of code or bytes copied? Code size is not too important, (under 256 bytes preferred), bytes copied each call is either 48 or 56 Questions -I understand the first two routines, but I don't understand why in the main routine at all. Why the constants ($1234 and $5678)? thank you! Edit: Wait a second, do memcopy and loop perform the actual copy and main simply sets up and calls it?

Both source and destination are variable - the amount of data to copy is always 56 bytes - however I think I'd like to be able to specify that as well just in case I find another use for this code.

Nothing, but I couldn't see how to pass the parameters that I need - sorry to have ignored your response!

Time to make some space! Reasonable offers considered, I will ship to US and Canada. If you are interested in a trade, I am looking for the packaging that comes with Synapse's Page 6 utility. Please read the descriptions beside each item - feel free to ask questions! Boxed 1050 in almost new condition. Tested and working. All components included. Box has some brown packing tape attached. Includes DOS 3 !!! ? 400 - includes Tara aftermarket keyboard. Early model - Week 12 of 1981. Machine powers up but does not boot or display anything. Parts only! 48K 800 - Parts only - missing spring from door latch, IO bezel and clear plastic power light carrier. Small chip in front right corner. 810 Drive - powers up, spins but otherwise does not respond. Small chip on one side. For parts. 2 - 850 interfaces - they power up but otherwise not tested. One has some fairly significant case damage. XEGS #1 - Bad ROM (no basic or Missile command), runs the cartridges I tested with, but no guarantees. Does not respond to keyboard. XEGS #2 - Tested and working except for sticky console keys (Option works only intermittently) XEGS #3 - Tested and working properly

thanks for the responses! Sounds like I was starting with the wrong code. Can anyone recommend an assembly routine that would do the following: -Copy small sequences of data (<64 bytes) from one location to another -Run in the VBI -Compatible with the TASM cross assembler version 3.2 -Fast and light thank you!

Thank you - much appreciated! Progress! It now simply hangs the computer instead of crashing Altirra! ? I think I forgot to mention that this needs to run in the VBI. Does that change anything?

I assume this is eye-rollingly simple, but I'll ask anyway ... I'm trying to modify a general purpose copy routine to use three parameters - a source location, a destination location and the number of bytes to copy. Can someone please have a look at the attached code and tell me what I am doing wrong? ; ; Ullrich von Bassewitz, 2003-08-20 ; Performance increase (about 20%) by ; Christian Krueger, 2009-09-13 ; ; void* __fastcall__ memcpy (void* dest, const void* src, size_t n); ; ; NOTE: This function contains entry points for memmove, which will resort ; to memcpy for an upwards copy. Don't change this module without looking ; at memmove! ; ; .export _memcpy, memcpy_upwards, memcpy_getparams ; .import popax, popptr1 ; .importzp sp, ptr1, ptr2, ptr3 ; ---------------------------------------------------------------------- ;; ;; compiler directives ;; .lsfirst ;; ;; TASM Macros and Defines ;; #define lo(work) (work & $00FF) #define hi(work) ((work & $FF00) >> 8) #define bitprefix .byte $2C zplocation .equ $CC ;; Uses memory locations starting at this address. Make sure they are not in use by the system or your program. org .equ $4C00 ;; Start of main code sp .equ zplocation+$0 ;; Source pointer ptr1 .equ zplocation+$2 ;; Source ptr2 .equ zplocation+$4 ;; Destination ptr3 .equ zplocation+$6 ;; Size popax .equ $BA ;; popptr1 .equ $BB ;; ;; program_start ;; ;; .org org _memcpy jsr memcpy_getparams .export _memcpy memcpy_upwards ; assert Y = 0 ldx ptr3+1 ; Get high byte of n beq L2 ; Jump if zero L1 ; Unrolled to make it faster... lda (ptr1),Y ; copy a byte sta (ptr2),Y iny lda (ptr1),Y ; copy a byte sta (ptr2),Y iny bne L1 inc ptr1+1 inc ptr2+1 dex ; Next 256 byte block bne L1 ; Repeat if any ; the following section could be 10% faster if we were able to copy ; back to front - unfortunately we are forced to copy strict from ; low to high since this function is also used for ; memmove and blocks could be overlapping! ; { L2 ; assert Y = 0 ldx ptr3 ; Get the low byte of n beq done ; something to copy L3 lda (ptr1),Y ; copy a byte sta (ptr2),Y iny dex bne L3 ; } done jmp popax ; Pop ptr and return as result .export memcpy_upwards ; ---------------------------------------------------------------------- ; Get the parameters from stack as follows: ; ; size --> ptr3 ; src --> ptr1 ; dest --> ptr2 ; First argument (dest) will remain on stack and is returned in a/x! memcpy_getparams ; IMPORTANT! Function has to leave with Y=0! sta ptr3 stx ptr3+1 ; save n to ptr3 jsr popptr1 ; save src to ptr1 ; save dest to ptr2 iny ; Y=0 guaranteed by popptr1, we need '1' here... ; (direct stack access is three cycles faster ; (total cycle count with return)) lda (sp),y tax stx ptr2+1 ; save high byte of ptr2 dey ; Y = 0 lda (sp),y ; Get ptr2 low sta ptr2 rts .export memcpy_getparams .end thank you! Copy.A65