Jump to content


  • Content Count

  • Joined

  • Last visited

Community Reputation

399 Excellent

About ZackAttack

  • Rank

Profile Information

  • Gender
  • Location
    Orlando, FL US
  1. You could also position the first copy far enough right so the second copy wraps around to the left side of the screen.
  2. Keep in mind the peripheral clock is typically slower than the core CPU clock. You're correct though. It's possible to get a stable address that is not the next actual address. In practice this isn't really an issue because it's no different than having a really fast rom. There will be some transient values driven on the data bus while the address settles down, but eventually the correct address/data pair are produced and because there's a considerable delay between when the address is valid and the data is read it's always sorted itself out in time. The one exception to this is pitfall 2 because a lot more processing is done for each address and sometimes this can trip it up. I made a custom firmware build that logged the stable addresses to SD card when we were troubleshooting an issue with a specific system. On my 2600 jr it would pick up at least one wrong address for every right address. You could poll for longer but the problem with that is it increases latency and could lead to a failure to service the data bus in time. To get around this problem and allow useful work to be done in place of the address polling I keep track of what the next ROM address would be and wait for the address bus to be set to that before proceeding to update the data bus. This allows the data value to be calculated in advanced and also eliminates servicing any transient address values. The only downside is that you have to emulate enough of the 6502 to know which rom address comes next. For my purposes it's not difficult since I run all my game logic in ARM and only use a few load/store instructions to update the TIA registers. That project is also open source.
  3. Why don't you start posting some graphics? If you provide some screen mockups you'll get feedback on what is and isn't possible with a classic 4/8k game. You'll have a better chance at recruiting programmers or programming it yourself if the game design is well documented and properly matched to the 2600 limitations.
  4. I posted a separate topic with bin herehttp://atariage.com/forums/topic/279712-raycasting-with-bus-stuffing-demo/?fromsearch=1
  5. Exactly. What's involved in making a faithful port is fundamentally different than making an original game. This is why I think ports deserve their own category. Separating them does not imply that either approach is better or easier.
  6. I'd actually argue the other direction for categories. Instead of adding one for 4k/assembly the bB category should be removed. Either it's a fun game to play or it's not. Who cares how it was built. A better category would be for ports/demakes since the game design effort is mostly provided by the original IP.
  7. You can find a fully working example of this in the Collect Tutorial. A 2 byte variable is created to hold the pointer to the human graphics. ORG $80 HumanPtr: ds 2 ; used for drawing player0 The address of the graphics to point to is calculated and stored in HumanPtr. Note that since this is a 2 byte pointer variable the low byte is stored at HumanPtr and the high byte is stored at HumanPtr+1. ; HumanPtr = HumanGfx + HUMAN_HEIGHT - 1 - Y position lda #<(HumanGfx + HUMAN_HEIGHT - 1) sec sbc ObjectY sta HumanPtr lda #>(HumanGfx + HUMAN_HEIGHT - 1) sbc #0 sta HumanPtr+1 Indirect Y addressing is used to load a byte from the array stored at the location pointed to by HumanPtr with the index/offset specified by Y. lda (HumanPtr),y ; 5 28 - load the shape for player0
  8. Sure. It's probably better to ask a more specific question when you get there though. The general idea would be to have a label followed by some ROM data and then use LABEL,X as the addressing mode. If you need another level of indirection it may be necessary to go with (),y. In which case you'd have multiple arrays in ROM and a 2 byte pointer variable in RAM. You'd copy the pointer to RAM for the desired array before the loop and then use (POINTER_VAR),Y inside the loop.
  9. If you intend on ORing 64 with each of them you would want to use the immediate mode for the ORA instruction. As far as indexing the different virtual sprites, that would depend on how they are laid out in memory. If they are all sequential in a chuck of contiguous memory there is no need for _byte. There are several ways to go about this, but I'd expect it to look something like this: SEG.U VARS ORG $80 NUSIZ_ARRAY ; Multiple labels at same address since both the array and NUSIZ0 are located starting here NUSIZ0 ds 1 NUSIZ1 ds 1 NUSIZ2 ds 1 ; Set bit $20 for NUSIZ0-NUSIZ2 LDX 2 ; start with NUSIZ2 and work back to 0 Loop: LDA NUSIZ_ARRAY,x ORA #64 STA NUSIZ_ARRAY,x DEX BPL Loop
  10. The UnoCart has support for ACE which is another scheme that allows game code to be offloaded to the ARM core. DPC+ and CDF are currently capped at 32kb rom and 8kb ram. ACE supports 448kb of rom and 192kb ram. On the flip side there are many quality homebrews which have already been released for DPC+ and CDF as well as some excellent documentation for developers. ACE is still largely undocumented and there is currently only a single game in development for it. I'd recommend getting both carts if you can afford it.
  11. Perhaps I'm missing some critical details to properly answer your question, but couldn't you just substitue any 5V parallel SRAM chip? I did a quick search on digikey and found a bunch for under $4 (USD). Sure they have much more than 128 bytes. Just limit how much of it you actually use in your implementation.
  12. I haven't heard anything other than what was posted in this thread. If you're getting a lot of dpc failure reports with the current version it would probably be worth moving to the latest. Otherwise I'd probably just stick with what you've been using and direct anyone with dpc issues to the experimental version. Some time in the near future I plan on making another build available that will address a very rare problem with JRs and another issue that appears to be related to the startup speed of the cart.
  13. Can't you just use a melody/harmony or unocart? Either one can be flashed as a standalone cart and they both should support whichever bank scheme you want to use.
  14. Off the top of my head without testing or optimizing I think something like this would work: ; pet movement code lda PetX clc adc PetVX sta PetX cmp #LEFTBOUNDRY bcc ReversePetDirection ; PetX < 20 cmp #RIGHTBOUNDRY bcs ReversePetDirection ; PetX > 144 jmp SkipReversePetDirection ; 20 < PetX && PetX < 144 ReversePetDirection: lda PetVX eor #$ff clc ; must clear carry because it's set or cleared depending on which boundary violation got us here adc #1 sta PetVX ; TODO This would be a good place to toggle the reflection flag if Pet has a directional sprite SkipReversePetDirection Regarding your solution, I think the first adc #0 should actually be adc #1 since the carry flag would need to be cleared to take that code path. If you find that the pet is speeding up each time it crosses the screen twice, that's why. Personally I'd probably just clc before every adc operation until you have a need to start optimizing. Even then you'll probably find better places to start optimizing (low hanging fruit). Hope that helps. -Zack
  15. Still feels wrong to me. If your position is 155 you are greater than 20 and branch past the reversedirection code as well as the second check for the right-boundary condition. In a higher level language I think you've created this: if(x < 20) { if(x > 144) { ReverseDirection(); } } But what you really want is this: if((x < 20) || (x > 144)) ReverseDirection(); Or with the logic inverted: if(!(20 < x && x < 144)) ReverseDirection();
  • Create New...