Trionoids - Columns Clone for the Falcon - RELEASED!

[christos]

I just had the chance to test Trionoids. For the good parts, I really liked the graphics and the motion. On the bad part I'd say I'd prefer a different control scheme. So think about it for the next game. Jagpad support would also be nice.
In short, I really liked it even though the control scheme needs a bit getting used to.

[LaceySnr]

I just had the chance to test Trionoids. For the good parts, I really liked the graphics and the motion. On the bad part I'd say I'd prefer a different control scheme. So think about it for the next game. Jagpad support would also be nice.
In short, I really liked it even though the control scheme needs a bit getting used to.

Thanks Christos! I did want to add Jagpad support but just never got around to it, maybe I'll dig my jag pads out and do an update soon. The fire button would likely feel more 'natural' for rotating the colours through, but I wanted you to be able to rotate up and down so went with the stick movements.

[EstTeeEfEm]

I've some code for the Jagpads, word of warning though... its not at all reliable on any emu i've tested, its either one button or screws with the keyboard or some other brand of wickedness... bear with

[EstTeeEfEm]

And here is the famed Jag Code.. straight out of Frogger... I've included the actual bit representations too for your convenience... sorry for the lack of comments tho

Code: Select all

;******************************************************************************
;
;	Jaguar PowerPad Code
;
;******************************************************************************


	even
jagpad_A
	;break
;group4 clearance
	move.b	#0,jagpad_a_up
	move.b	#0,jagpad_a_down
	move.b	#0,jagpad_a_left
	move.b	#0,jagpad_a_right
	move.b	#0,jagpad_a_fire_a


	bsr	jagpad_A_group_4


	rts




*******************************************************************************
jagpad_A_group_4
;Group 4 Selections
	move.w	#$FFFE,$ffff9202		;Select group 4 of Joypad A
	move.w	$FFFF9200,d0
	move.w	$FFFF9202,d1
	;cmp.l	#-1,player_moving
	;bgt	no_pad_movement

;test_padA_controls
	btst	#8,d1			;Test bit #8 for a ZERO
	bne	.no_pad_up		;No, the UP NOT being pressed 1=off 0=on
	move.b	#1,jagpad_a_up
.no_pad_up
	btst	#9,d1			;Test bit #9 for a ZERO
	bne	.no_pad_down		;No, the DOWN NOT being pressed 1=off 0=on
	move.b	#1,jagpad_a_down
.no_pad_down
	btst	#10,d1			;Test bit #10 for a ZERO
	bne	.no_pad_left		;No, the LEFT NOT being pressed 1=off 0=on
	move.b	#1,jagpad_a_left
.no_pad_left
	btst	#11,d1			;Test bit #11 for a ZERO
	bne	.no_pad_right		;No, the RIGHT NOT being pressed 1=off 0=on
	move.b	#1,jagpad_a_right
.no_pad_right


;9200 Test, FIRE and PAUSE

	btst	#1,d0			;Test bit #1 in FF9000 for FIRE (A) Pad A
	bne	.no_fire_a
	move.b	#1,jagpad_a_fire_a
.no_fire_a

no_pad_movement
	rts

;******************************************************************************
;Steps to programming Atari Jaguar Controller - ALL Buttons

;Write to address $FF9202 - Set the type of control line (Or Group) you wish to test

;READ from address $FFFF9200 and $ff9202 
;	0xFFFE	Selects group 4, joypad A - PAUSE  - FIRE_A - UP - DOWN - LEFT - RIGHT
;	0xFFFD	Selects group 3, joypad A -          FIRE_B - * - 7 - 4 - 1
;	0xFFFB	Selects group 2, joypad A -          FIRE_C - 0 - 8 - 5 - 2
;	0xFFF7	Selects group 1, joypad A -          OPTION - # - 9 - 6 - 3 

;group4




jag_bitmask_a	ds.l	1
jag_bitmask_b	ds.l	1
	even
jagpad_a_up		ds.b	1
jagpad_a_down		ds.b	1
jagpad_a_left		ds.b	1
jagpad_a_right		ds.b	1
jagpad_a_fire_a		ds.b	1
	even


;*****************************************************************************
;	Group 4		Group 3		Group 2 	Group 1
;	=======		=======		=======		=======
;
;0xFF9200
;========
;
;Bit 0	A PAUSE		  N/A		  N/A		  N/A
;
;Bit 1	A FIRE A	A FIRE B	A FIRE C	A OPTION
;
;Bit 2	B PAUSE		  N/A		  N/A		  N/A
;
;Bit 3	B FIRE A	B FIRE B	B FIRE C	B OPTION
;
;
;0xFF9202
;========
;
;Bit 8	A UP		  A *		  A 0		  A #
;
;Bit 9	A DOWN		  A 7		  A 8		  A 9
;
;Bit 10	A LEFT		  A 4		  A 5		  A 6
;
;Bit 11	A RIGHT		  A 1		  A 2		  A 3
;
;Bit 12	B UP		  B *		  B 0		  B #
;
;Bit 13	B DOWN		  B 7		  B 8		  B 9
;
;Bit 14	B LEFT		  B 4		  B 5		  B 6
;
;Bit 15	B RIGHT		  B 1		  B 2		  B 3

[EstTeeEfEm]

And some rather nifty TEXT displaying TEST program written by XiA

Im sure he wont mind me spreading this, but whether he owns upto it or not is another matter

Code: Select all

NUMBER_OF_VBLS_BETWEEN_UPDATES equ 5

JAGPAD_SELECT_GROUP_1 equ $fff7
JAGPAD_SELECT_GROUP_2 equ $fffb
JAGPAD_SELECT_GROUP_3 equ $fffd
JAGPAD_SELECT_GROUP_4 equ $fffe

; $ffff9200
JAGPAD_BIT_A_PAUSE  equ 0
JAGPAD_BIT_A_FIRE_A equ 1
JAGPAD_BIT_A_FIRE_B equ 1
JAGPAD_BIT_A_FIRE_C equ 1
JAGPAD_BIT_A_OPTION equ 1

; $ffff9202
JAGPAD_BIT_A_UP       equ 0
JAGPAD_BIT_A_ASTERISK equ 0
JAGPAD_BIT_A_0        equ 0
JAGPAD_BIT_A_HASH     equ 0
JAGPAD_BIT_A_DOWN     equ 1
JAGPAD_BIT_A_7        equ 1
JAGPAD_BIT_A_8        equ 1
JAGPAD_BIT_A_9        equ 1
JAGPAD_BIT_A_LEFT     equ 2
JAGPAD_BIT_A_4        equ 2
JAGPAD_BIT_A_5        equ 2
JAGPAD_BIT_A_6        equ 2
JAGPAD_BIT_A_RIGHT    equ 3
JAGPAD_BIT_A_1        equ 3
JAGPAD_BIT_A_2        equ 3
JAGPAD_BIT_A_3        equ 3


start:
  pea code
  move.w #$26,-(sp)
  trap #14
  addq.l #6,sp

code:
  lea str_clear_screen,a6
  bsr print_string
  lea output,a0
  ; group 1
  move.w #JAGPAD_SELECT_GROUP_1,$ffff9202
  move.w $ffff9200,(a0)+
  move.w $ffff9202,(a0)+
  ; group 2
  move.w #JAGPAD_SELECT_GROUP_2,$ffff9202
  move.w $ffff9200,(a0)+
  move.w $ffff9202,(a0)+
  ; group 3
  move.w #JAGPAD_SELECT_GROUP_3,$ffff9202
  move.w $ffff9200,(a0)+
  move.w $ffff9202,(a0)+
  ; group 4
  move.w #JAGPAD_SELECT_GROUP_4,$ffff9202
  move.w $ffff9200,(a0)+
  move.w $ffff9202,(a0)+


  ; output texts
  lea output,a0
  ; -- GROUP 1

  ; option
  btst.b #JAGPAD_BIT_A_OPTION,(a0)
  bne .nooption
  lea str_option,a6
  bsr print_string
.nooption:

  add.w #2,a0

  ; hash
  btst.b #JAGPAD_BIT_A_HASH,(a0)
  bne .nohash
  lea str_hash,a6
  bsr print_string
.nohash:

  ; 9
  btst.b #JAGPAD_BIT_A_9,(a0)
  bne .no9
  lea str_9,a6
  bsr print_string
.no9:

  ; 6
  btst.b #JAGPAD_BIT_A_6,(a0)
  bne .no6
  lea str_6,a6
  bsr print_string
.no6:

  ; 3
  btst.b #JAGPAD_BIT_A_3,(a0)
  bne .no3
  lea str_3,a6
  bsr print_string
.no3:

  add.w #2,a0

  ; -- GROUP 2

  ; fire c
  btst.b #JAGPAD_BIT_A_FIRE_C,(a0)
  bne .nofire_c
  lea str_fire_c,a6
  bsr print_string
.nofire_c:

  add.w #2,a0

  ; 0
  btst.b #JAGPAD_BIT_A_0,(a0)
  bne .no0
  lea str_0,a6
  bsr print_string
.no0:

  ; 8
  btst.b #JAGPAD_BIT_A_8,(a0)
  bne .no8
  lea str_8,a6
  bsr print_string
.no8:

  ; 5
  btst.b #JAGPAD_BIT_A_5,(a0)
  bne .no5
  lea str_5,a6
  bsr print_string
.no5:

  ; 2
  btst.b #JAGPAD_BIT_A_2,(a0)
  bne .no2
  lea str_2,a6
  bsr print_string
.no2:

  add.w #2,a0

  ; -- GROUP 3

  ; fire b
  btst.b #JAGPAD_BIT_A_FIRE_B,(a0)
  bne .nofire_b
  lea str_fire_b,a6
  bsr print_string
.nofire_b:

  add.w #2,a0

  ; *
  btst.b #JAGPAD_BIT_A_ASTERISK,(a0)
  bne .noasterisk
  lea str_asterisk,a6
  bsr print_string
.noasterisk:

  ; 7
  btst.b #JAGPAD_BIT_A_7,(a0)
  bne .no7
  lea str_7,a6
  bsr print_string
.no7:

  ; 4
  btst.b #JAGPAD_BIT_A_4,(a0)
  bne .no4
  lea str_4,a6
  bsr print_string
.no4:

  ; 1
  btst.b #JAGPAD_BIT_A_1,(a0)
  bne .no1
  lea str_1,a6
  bsr print_string
.no1:

  add.w #2,a0

  ; -- GROUP 4

  ; fire a
  btst.b #JAGPAD_BIT_A_FIRE_A,(a0)
  bne .nofire_a
  lea str_fire_a,a6
  bsr print_string
.nofire_a:

  add.w #2,a0

  ; up
  btst.b #JAGPAD_BIT_A_UP,(a0)
  bne .noup
  lea str_up,a6
  bsr print_string
.noup:

  ; down
  btst.b #JAGPAD_BIT_A_DOWN,(a0)
  bne .nodown
  lea str_down,a6
  bsr print_string
.nodown:

  ; left
  btst.b #JAGPAD_BIT_A_LEFT,(a0)
  bne .noleft
  lea str_left,a6
  bsr print_string
.noleft:

  ; right
  btst.b #JAGPAD_BIT_A_RIGHT,(a0)
  bne .noright
  lea str_right,a6
  bsr print_string
.noright:  

  move.l #NUMBER_OF_VBLS_BETWEEN_UPDATES-1,d7
.wait:
    move.w #$25,-(sp)
    trap #14
    add.l #2,sp
  dbra d7,.wait
  bra code

  lea output,a0
  clr.b $ffffc123


print_string:
; In: a6: pointer to null-terminated string
  movem.l d0-d7/a0-a6,-(sp)
  move.l a6,-(sp)
  move.w #9,-(sp)
  trap #1
  add.l #6,sp
  movem.l (sp)+,d0-d7/a0-a6
  rts



bye:
  bra bye

str_clear_screen:
  dc.b 27,"E",0
  even

str_pause:  dc.b "pause",13,10,0
  even
str_fire_a:  dc.b "fire A",13,10,0
  even
str_fire_b:  dc.b "fire B",13,10,0
  even
str_fire_c:  dc.b "fire C",13,10,0
  even
str_option:  dc.b "option",13,10,0
  even

str_up:     dc.b "up",13,10,0
  even
str_asterisk:     dc.b "asterisk",13,10,0
  even
str_0:     dc.b "0",13,10,0
  even
str_hash:     dc.b "hash",13,10,0
  even
str_down:     dc.b "down",13,10,0
  even
str_7:     dc.b "7",13,10,0
  even
str_8:     dc.b "8",13,10,0
  even
str_9:     dc.b "9",13,10,0
  even
str_left:     dc.b "left",13,10,0
  even
str_4:     dc.b "4",13,10,0
  even
str_5:     dc.b "5",13,10,0
  even
str_6:     dc.b "6",13,10,0
  even
str_right:     dc.b "right",13,10,0
  even
str_1:     dc.b "1",13,10,0
  even
str_2:     dc.b "2",13,10,0
  even
str_3:     dc.b "3",13,10,0
  even
  

output:
  ds.w 8

[LaceySnr]

Nice one, I'll have a play sometime. What's this line for?

move.w #$FFFE,$ffff9202 ;Select group 4 of Joypad A

Seems a little odd to write some values there before reading, what's in those lower bits?

[EstTeeEfEm]

In multiplexing, you need to select one of the four groups first, before reading them because the same bits represent different values, this is what screws the emulators

1) Write a value to address 0xFF9202. This sets the
control lines on the multiplexers.

2) Read the values at 0xFF9200 and/or 0xFF9202. These
will have certain bits cleared (set to LOW) to
indicate which switches in a group are being pressed.


The value that you write in step one is made up as follows: it is a
long, whose lower four bits represent the control inputs of joypad A,
and whose next four bits (5-7) represent the control inputs of joypad
B. For example:-

0xFFFE Selects group 4, joypad A for reading
0xFFFD Selects group 3, joypad A
0xFFFB Selects group 2, joypad A
0xFFF7 Selects group 1, joypad A

0xFFEF Selects group 4, joypad B for reading
0xFFDF Selects group 3, joypad B
0xFFBF Selects group 2, joypad B
0XFF7F Selects group 1, joypad B


Once you have written the requisite mask to 0xFF9202, you can read
back the state of the joypad(s) from 0xFF9200 and 0xFF9202. Since the
joypad works on NEGATIVE LOGIC, a bit is CLEARED whenever a button is
pressed. In the table below, the first letter indicates the port that
is being read, so A FIRE B represents fire button B on the joypad
attached to port A. The exact bit that is cleared determines which
button has been pressed as follows:-

Okay, so having probably confused everyone now, here's the summary. To
read a joypad, simply write a value to 0xFF9202 with bit 0, 1, 2 or 3
low (and/or 4, 5, 6 or 7 for port B) depending on which group you want
to read. Next read from 0xFF9200 and/or 0xFF9202 to obtain a bitmask
giving the buttons in that group that were pressed, as in the table
above. Clear as Guinness or what!!?!?

This is taken from the following guide which is ESSENTIAL to better understanding the Jagpads...

http://www.gamesx.com/controldata/ejp_faq.htm

The guide URL abpve is really the only way its explained in great detail.. please read it

I hope i've been a little bit helpful lol, its a real nightmare, BUT, once you've written some jagpad code, mine above in the previous thread will make a LOT more sense lol