turbo software

[dogdark]

yo ya los probe con todos y el mejor que me funciono fue el atari800win ahí funcionan todas hasta el maldito gato que no me funka en el note

[bladehack]

Hola a todos:

Estoy tratando de pasar un XEX a WAV con el loader de Turbo Soft hecho en python , pero me sale el sgte error:

Código: Seleccionar todo

C:\Python33>python a8turbo.py river.xex river.wav
XEX size: 8381
A8 tape sectors 67
Traceback (most recent call last):
  File "a8turbo.py", line 62, in <module>
    generate(sys.argv[1], sys.argv[2])
  File "a8turbo.py", line 45, in generate
    for i in turbo_data.ts_header: cas.rblock(i['igr'], i['data'])
  File "C:\Python33\a8cas.py", line 62, in rblock
    self.f.write(struct.pack("<%dh" % s, *self.osc_write(s, self.space_mark[1]))
)
struct.error: required argument is not an integer

Alguien sabe que pasa?



Me respondo solo. El error me sale por usar el Python33 y no el 27.

Por otra parte, creo que el WAV generado con la nueva aplicacion en python, podría ocupar menos espacio si el archivo de audio generado fuera de 44Khz, 352kbps (8bits) en vez de 44Khz, 705kbps (16 bits). Lo digo porque poseo varios archivos creados hace mucho con otra aplicacion que hizo Xt5 que se llamaba xex2pong. Esta pasaba un XEX a el loader Turbo Soft en un archivo CAS, el que convetía a WAV para parchar el 3er bloque donde esta la protección, y los archivos efectivamente de audio en WAV estan en 8 bits (cosa que al comprimirla con RAR quedaba un archivo con tamaño promedio de 400 KB)

[dogdark]

lo que pasa por lo que tengo entendido a python en la versión 3 en adelante le faltan algunas aplicaciones por eso te da algunos errores, con el copiador turbo usamos el 2.7 que es la versión mas estable y con todas sus librerías, el porque lo desconosco porque no se python tendrías que esperar a xt5 que entiende de eso para explicarte bien cual es el error, trabaja con ña versión que te digo 2.7 y no te dara problemas en los juegos, caso raro alguno que otro, en este en lace hice un video tutorial de como se hace la conversión paso a paso

viewtopic.php?f=33&t=363

y en este enlace ya esta pasado el river raid que es el juego que supongo que es el que estas pasando

http://atarigames.cl/wp-content/uploads ... warext5.7z

[xt5]

Se le puede dar soporte a Python3, el problema es que Python en muchas cosas perdió retrocompatibilidad en la version 3 y hay que hacer chequeos de versión, todo un cacho.

Agrego el asunto de los 8bits a la lista de cosas que hacer, con suerte hay que cambiar unas pocas lineas.

[bladehack]

Pude usar el Loader al final. Subo un juego, el Scraming Wings que esta comprimido el XEX, por lo que el tiempo de carga del juego queda en 6 minutos mas o menos, versus los 13 que toma normal. Como me di cuenta en el post, han tenido problemas con la direccion de memoria donde se ejecuta el XEX y el Loader. Por ello tengo un programa en BASIC hecho por Willysoft el que modifica la direccion donde se ejecuta el Juego una vez comprimido con el Cruncher (con esto no interfiere el loader Turbosoft con el archivo que se descomprimirá). Lo subo tambien por si alguien se anima a examinarlo.

Saludos

1942comp.7z

Screaming Wings 1942 Comprimido con el Magnus Cruncher 5.0
(Carga en 6:45)

(679.13 KiB) Descargado 126 veces

[Suppawer]

Con tanto hablar de Python, me animé no más con py2exe. Aquí está el EXE del programa de xt5 (no requiere tener instalado Python).
Descargar a8turbo

Sólo añadí un par de cosas:



Probado en Win Xp y en Win 7 64

[dogdark]

en el emulador corre sin problemas, en el atari real no me corre, al parecer problemas con la cassetera, que con suerte leeee, te aviso a posterior cuando encuentre otra porque la que tengo esta muriendo.

en todo caso seguire por elbasic aunque no me dsale nada, con el assembler quedo pillo

[dogdark]

franco me llamo mucho la atencion de uno de tus copiadores que es el casII, este copiador tiene un archivo bin en donde tienes lo que se pasara al cassette, este copiador tambien tiene dos funciones, la de carga normal y turbo, a parte tembien tiene unaseccion donde se crea una portada en la carga, o sea carga el primer sector, despues si aceptas la portada se carga esta y despues se carga otra etapa donde va la info del juego, nombre , bloques faltantes, etc, este copiador no serviria para el turbo software???? o sea cambiar los datos del bin y usarlo y modificarlo para el copiador turbo????

Código: Seleccionar todo

;
; System equates
;
; OS EQUATES
; ----------
; 
; Syntax:
; Use '=' for addresses
; and '<' for read addresses (ex: KBCODE)
; and '>' for write addresses (ex: STIMER)
; and '#' for values
; 
; IO EQUATES
; 
ICHID       = $0000
ICDNO       = $0001
ICCOM       = $0002
ICSTA       = $0003
ICBAL       = $0004
ICBAH       = $0005
ICPTL       = $0006
ICPTH       = $0007
ICBLL       = $0008
ICBLH       = $0009
ICAX1       = $000A
ICAX2       = $000B
ICAX3       = $000C
ICAX4       = $000D
ICAX5       = $000E
ICAX6       = $000F
; 
; DISPLAY LIST EQUATES
; 
ADLI        = $0080
AVB         = $0040
ALMS        = $0040
AVSCR       = $0020
AHSCR       = $0010
AJMP        = $0001
AEMPTY1     = $0000
AEMPTY2     = $0010
AEMPTY3     = $0020
AEMPTY4     = $0030
AEMPTY5     = $0040
AEMPTY6     = $0050
AEMPTY7     = $0060
AEMPTY8     = $0070
; 
; OS VARIABLES FOR XL/XE
; 
; PAGE 0
; 
NGFLAG      = $0001
CASINI      = $0002
RAMLO       = $0004
TRAMSZ      = $0006
CMCMD       = $0007
WARMST      = $0008
BOOT        = $0009
DOSVEC      = $000A
DOSINI      = $000C
APPMHI      = $000E
POKMSK      = $0010
BRKKEY      = $0011
RTCLOK      = $0012
BUFADR      = $0015
ICCOMT      = $0017
DSKFMS      = $0018
DSKUTL      = $001A
ABUFPT      = $001C
ICHIDZ      = $0020
ICDNOZ      = $0021
ICCOMZ      = $0022
ICSTAZ      = $0023
ICBALZ      = $0024
ICBAHZ      = $0025
ICPTLZ      = $0026
ICPTHZ      = $0027
ICBLLZ      = $0028
ICBLHZ      = $0029
ICAX1Z      = $002A
ICAX2Z      = $002B
ICAX3Z      = $002C
ICAX4Z      = $002D
ICAX5Z      = $002E
ICAX6Z      = $002F
STATUS      = $0030
CHKSUM      = $0031
BUFRLO      = $0032
BUFRHI      = $0033
BFENLO      = $0034
BFENHI      = $0035
LTEMP       = $0036
BUFRFL      = $0038
RECVDN      = $0039
XMTDON      = $003A
CHKSNT      = $003B
NOCKSM      = $003C
BPTR        = $003D
FTYPE       = $003E
FEOF        = $003F
FREQ        = $0040
SOUNDR      = $0041
CRITIC      = $0042
FMSZPG      = $0043
ZCHAIN      = $004A
DSTAT       = $004C
ATRACT      = $004D
DRKMSK      = $004E
COLRSH      = $004F
TEMP        = $0050
HOLD1       = $0051
LMARGN      = $0052
RMARGN      = $0053
ROWCRS      = $0054
COLCRS      = $0055
DINDEX      = $0057
SAVMSC      = $0058
OLDROW      = $005A
OLDCOL      = $005B
OLDCHR      = $005D
OLDADR      = $005E
FKDEF       = $0060
PALNTS      = $0062
LOGCOL      = $0063
ADRESS      = $0064
MLTTMP      = $0066
SAVADR      = $0068
RAMTOP      = $006A
BUFCNT      = $006B
BUFSTR      = $006C
BITMSK      = $006E
SHFAMT      = $006F
ROWAC       = $0070
COLAC       = $0072
ENDPT       = $0074
DELTAR      = $0076
DELTAC      = $0077
KEYDEF      = $0079
SWPFLG      = $007B
HOLDCH      = $007C
INSDAT      = $007D
COUNTR      = $007E
LOMEM       = $0080
; 
; PAGE 2
; 
VDSLST      = $0200
VPRCED      = $0202
VINTER      = $0204
VBREAK      = $0206
VKEYBD      = $0208
VSERIN      = $020A
VSEROR      = $020C
VSEROC      = $020E
VTIMR1      = $0210
VTIMR2      = $0212
VTIMR4      = $0214
VIMIRQ      = $0216
CDTMV1      = $0218
CDTMV2      = $021A
CDTMV3      = $021C
CDTMV4      = $021E
CDTMV5      = $0220
VVBLKI      = $0222
VVBLKD      = $0224
CDTMA1      = $0226
CDTMA2      = $0228
CDTMF3      = $022A
SRTIMR      = $022B
CDTMF4      = $022C
INTEMP      = $022D
CDTMF5      = $022E
SDMCTL      = $022F
SDLSTL      = $0230
SDLSTH      = $0231
SSKCTL      = $0232
SPARE       = $0233
LPENH       = $0234
LPENV       = $0235
BRKKY       = $0236
VPIRQ       = $0238
CDEVIC      = $023A
CCOMND      = $023B
CAUX1       = $023C
CAUX2       = $023D
TMPSIO      = $023E
ERRFLG      = $023F
DFLAGS      = $0240
DBSECT      = $0241
BOOTAD      = $0242
COLDST      = $0244
RECLEN      = $0245
DSKTIM      = $0246
PDVMSK      = $0247
SHPDVS      = $0248
PDMSK       = $0249
RELADR      = $024A
PPTMPA      = $024C
PPTMPX      = $024D
CHSALT      = $026B
VSFLAG      = $026C
KEYDIS      = $026D
FINE        = $026E
GPRIOR      = $026F
PADDL0      = $0270
PADDL1      = $0271
PADDL2      = $0272
PADDL3      = $0273
PADDL4      = $0274
PADDL5      = $0275
PADDL6      = $0276
PADDL7      = $0277
STICK0      = $0278
STICK1      = $0279
STICK2      = $027A
STICK3      = $027B
PTRIG0      = $027C
PTRIG1      = $027D
PTRIG2      = $027E
PTRIG3      = $027F
PTRIG4      = $0280
PTRIG5      = $0281
PTRIG6      = $0282
PTRIG7      = $0283
STRIG0      = $0284
STRIG1      = $0285
STRIG2      = $0286
STRIG3      = $0287
HIBYTE      = $0288
WMODE       = $0289
BLIM        = $028A
IMASK       = $028B
JVECK       = $028C
NEWADR      = $028E
TXTROW      = $0290
TXTCOL      = $0291
TINDEX      = $0293
TXTMSC      = $0294
TXTOLD      = $0296
CRETRY      = $029C
HOLD3       = $029D
SUBTMP      = $029E
HOLD2       = $029F
DMASK       = $02A0
TMPLBT      = $02A1
ESCFLG      = $02A2
TABMAP      = $02A3
LOGMAP      = $02B2
INVFLG      = $02B6
FILFLG      = $02B7
TMPROW      = $02B8
TMPCOL      = $02B9
SCRFLG      = $02BB
HOLD4       = $02BC
DRETRY      = $02BD
SHFLOC      = $02BE
BOTSCR      = $02BF
PCOLR0      = $02C0
PCOLR1      = $02C1
PCOLR2      = $02C2
PCOLR3      = $02C3
COLOR0      = $02C4
COLOR1      = $02C5
COLOR2      = $02C6
COLOR3      = $02C7
COLOR4      = $02C8
RUNADR      = $02C9
HIUSED      = $02CB
ZHIUSE      = $02CD
GBYTEA      = $02CF
LOADAD      = $02D1
ZLOADA      = $02D3
DSCTLN      = $02D5
ACMISR      = $02D7
KRPDER      = $02D9
KEYREP      = $02DA
NOCLIK      = $02DB
HELPFG      = $02DC
DMASAV      = $02DD
PBPNT       = $02DE
PBUFSZ      = $02DF
RUNAD       = $02E0
INITAD      = $02E2
RAMSIZ      = $02E4
MEMTOP      = $02E5
MEMLO       = $02E7
HNDLOD      = $02E9
DVSTAT      = $02EA
CBAUDL      = $02EE
CBAUDH      = $02EF
CRSINH      = $02F0
KEYDEL      = $02F1
CH1         = $02F2
CHACT       = $02F3
CHBAS       = $02F4
NEWROW      = $02F5
NEWCOL      = $02F6
ROWINC      = $02F8
COLINC      = $02F9
CHAR        = $02FA
ATACHR      = $02FB
CH          = $02FC
FILDAT      = $02FD
DSPFLG      = $02FE
SSFLAG      = $02FF
; 
; PAGE 3
; 
DDEVIC      = $0300
DUNIT       = $0301
DCOMND      = $0302
DSTATS      = $0303
DBUFLO      = $0304
DBUFHI      = $0305
DTIMLO      = $0306
DUNUSE      = $0307
DBYTLO      = $0308
DBYTHI      = $0309
DAUX1       = $030A
DAUX2       = $030B
TIMER1      = $030C
ADDCOR      = $030E
CASFLG      = $030F
TIMER2      = $0310
TEMP1       = $0312
TEMP2       = $0314
TEMP3       = $0315
SAVIO       = $0316
TIMFLG      = $0317
STACKP      = $0318
TSTAT       = $0319
HATABS      = $031A
PUPBT1      = $033D
PUPBT2      = $033E
PUPBT3      = $033F
IOCB0       = $0340
IOCB1       = $0350
IOCB2       = $0360
IOCB3       = $0370
IOCB4       = $0380
IOCB5       = $0390
IOCB6       = $03A0
IOCB7       = $03B0
PRNBUF      = $03C0
SUPERF      = $03E8
CKEY        = $03E9
CASSBT      = $03EA
CARTCK      = $03EB
DERRF       = $03EC
ACMVAR      = $03ED
BASICF      = $03F8
MINTLK      = $03F9
GINTLK      = $03FA
CHLINK      = $03FB
CASBUF      = $03FD
; 
; HARDWARE REGISTERS
; 
; GTIA
; 
M0PF        = $D000
HPOSP0      = $D000
M1PF        = $D001
HPOSP1      = $D001
M2PF        = $D002
HPOSP2      = $D002
M3PF        = $D003
HPOSP3      = $D003
P0PF        = $D004
HPOSM0      = $D004
P1PF        = $D005
HPOSM1      = $D005
P2PF        = $D006
HPOSM2      = $D006
P3PF        = $D007
HPOSM3      = $D007
M0PL        = $D008
SIZEP0      = $D008
M1PL        = $D009
SIZEP1      = $D009
M2PL        = $D00A
SIZEP2      = $D00A
M3PL        = $D00B
SIZEP3      = $D00B
P0PL        = $D00C
SIZEM       = $D00C
P1PL        = $D00D
GRAFP0      = $D00D
P2PL        = $D00E
GRAFP1      = $D00E
P3PL        = $D00F
GRAFP2      = $D00F
TRIG0       = $D010
GRAFP3      = $D010
TRIG1       = $D011
GRAFM       = $D011
TRIG2       = $D012
COLPM0      = $D012
TRIG3       = $D013
COLPM1      = $D013
PAL         = $D014
COLPM2      = $D014
COLPM3      = $D015
COLPF0      = $D016
COLPF1      = $D017
COLPF2      = $D018
COLPF3      = $D019
COLBK       = $D01A
PRIOR       = $D01B
VDELAY      = $D01C
GRACTL      = $D01D
HITCLR      = $D01E
CONSOL      = $D01F
; 
; POKEY
; 
POT0        = $D200
AUDF1       = $D200
POT1        = $D201
AUDC1       = $D201
POT2        = $D202
AUDF2       = $D202
POT3        = $D203
AUDC2       = $D203
POT4        = $D204
AUDF3       = $D204
POT5        = $D205
AUDC3       = $D205
POT6        = $D206
AUDF4       = $D206
POT7        = $D207
AUDC4       = $D207
ALLPOT      = $D208
AUDCTL      = $D208
KBCODE      = $D209
STIMER      = $D209
RANDOM      = $D20A
SKREST      = $D20A
POTGO       = $D20B
SERIN       = $D20D
SEROUT      = $D20D
IRQST       = $D20E
IRQEN       = $D20E
SKSTAT      = $D20F
SKCTL       = $D20F
; 
; PIA
; 
PORTA       = $D300
PORTB       = $D301
PACTL       = $D302
PBCTL       = $D303
; 
; ANTIC
; 
DMACLT      = $D400
CHACTL      = $D401
DLISTL      = $D402
DLISTH      = $D403
HSCROL      = $D404
VSCROL      = $D405
PMBASE      = $D407
CHBASE      = $D409
WSYNC       = $D40A
VCOUNT      = $D40B
PENH        = $D40C
PENV        = $D40D
NMIEN       = $D40E
NMIST       = $D40F
NMIRES      = $D40F
; 
; FLOATING POINT ROUTINES
; 
AFP         = $D800
FASC        = $D8E6
IFP         = $D9AA
FPI         = $D9D2
ZFR0        = $DA44
ZF1         = $DA46
FSUB        = $DA60
FADD        = $DA66
FMUL        = $DADB
FDIV        = $DB28
PLYEVL      = $DD40
FLD0R       = $DD89
FLD0P       = $DD8D
FLD1R       = $DD98
FLD1P       = $DD9C
FSTOR       = $DDA7
FSTOP       = $DDAB
FMOVE       = $DDB6
EXP         = $DDC0
EXP10       = $DDCC
LOG         = $DECD
LOG10       = $DED1
; 
; ROM VECTORS
; 
DSKINV      = $E453
CIOV        = $E456
SIOV        = $E459
SETVBV      = $E45C
SYSVBV      = $E45F
XITVBV      = $E462
SIOINV      = $E465
SENDEV      = $E468
INTINV      = $E46B
CIOINV      = $E46E
SELFSV      = $E471
WARMSV      = $E474
COLDSV      = $E477
RBLOKV      = $E47A
CSOPIV      = $E47D
PUPDIV      = $E480
SELFTSV     = $E483
PENTV       = $E486
PHUNLV      = $E489
PHINIV      = $E48C
GPDVV       = $E48F

[fcatrin]

En realidad cualquiera de esos copiadores se puede modificar para lo que tu quieres hacer. Pero la rutina de grabación tendrís que ser modificada también, para que use el formato de bloques que espera el Turbo

[dogdark]

ok franco, seguire examinando los copiadores y la rutina que hiciste al principio

[dogdark]

tengo la siguiente duda, segun el codigo de xt5 con respecto al turbo software, existen dos variables que es ts_header y la segunda que es ts_pong, yo al pasar la primera como una variable HE$ en basic me quedaria por ejemplo "UU/77" etc, estas lineas que estan en 3 bloques en el ts_header veo que tiene 3 igr diferentes el 20205 , 344, 384

Código: Seleccionar todo

ts_header = [
{
 'igr': 20205, 
 'data': [
  0x55, 0x55, 0xfa, 0x00, 0x01, 0x80, 0x03, 0x56, 0xe4, 0xa2, 0x3b, 0x9a, 0x38, 0xbd, 0x99, 0x03,
  0xa8, 0xed, 0xff, 0x03, 0x8c, 0xff, 0x03, 0x48, 0xca, 0x10, 0xf1, 0x60, 0x6e, 0x6d, 0x6c, 0xca,
  0xc9, 0x3b, 0xf7, 0xf5, 0x2b, 0x9d, 0x6e, 0x6c, 0xde, 0xde, 0x0a, 0x84, 0x43, 0xa1, 0xb5, 0x2f,
  0x1b, 0x6e, 0x5f, 0x8d, 0x64, 0x54, 0x84, 0x8f, 0xe9, 0xd5, 0x05, 0x10, 0x63, 0x54, 0x82, 0x59,
  0x49, 0x59, 0x60, 0xbe, 0xb3, 0xf6, 0x21, 0x1e, 0x81, 0x81, 0x7e, 0xb4, 0xa4, 0xad, 0x8d, 0x34,
  0x50, 0xae, 0xaf, 0x15, 0xa9, 0xa5, 0xa2, 0x3a, 0x60, 0x00, 0x52, 0x40, 0x00, 0x20, 0x23, 0x00,
  0x3a, 0x02, 0x00, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  0x00, 0x00, 0x01, 0x54]},
{
 'igr': 344, 
 'data': [
  0x55, 0x55, 0xfc, 0x01, 0x00, 0x70, 0x56, 0xe4, 0xa9, 0x00, 0xa0, 0x02, 0x91, 0x58, 0x8d, 0xc6,
  0x02, 0x85, 0x41, 0xa2, 0x10, 0xa9, 0x03, 0x9d, 0xec, 0x02, 0x9d, 0x42, 0x03, 0xa9, 0x04, 0x9d,
  0x4a, 0x03, 0xa9, 0x80, 0x9d, 0x4b, 0x03, 0xa9, 0x31, 0x9d, 0x44, 0x03, 0xa9, 0xc4, 0x9d, 0x45,
  0x03, 0x20, 0x56, 0xe4, 0xa9, 0x00, 0x9d, 0x44, 0x03, 0x9d, 0x48, 0x03, 0xa9, 0x07, 0x9d, 0x45,
  0x03, 0xa9, 0x06, 0x9d, 0x49, 0x03, 0xa9, 0x07, 0x9d, 0x42, 0x03, 0x20, 0x56, 0xe4, 0x88, 0xb9,
  0x00, 0x07, 0x59, 0x00, 0x08, 0x9d, 0x00, 0x07, 0x88, 0xd0, 0xf4, 0xa9, 0x66, 0x8d, 0x30, 0x02,
  0xa9, 0x70, 0x8d, 0x31, 0x02, 0x4c, 0x00, 0x07, 0x70, 0x70, 0x70, 0x46, 0x6d, 0x70, 0x41, 0x00,
  0x00, 0x00, 0x74, 0x75, 0x72, 0x62, 0x6f, 0x00, 0x33, 0x2f, 0x26, 0x34, 0x37, 0x21, 0x32, 0x25,
  0x00, 0x00, 0x00, 0x18]},
{
 'igr': 384, 
 'data': [
  0x55, 0x55, 0xfe, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  0x00, 0x00, 0x00, 0xa9]}
]

la consulta es la siguiente, como tengo 3 igr diferentes, al pasar estos codigos hexadecimales a una variable que seria HE$, las coloco todas juntas, adjuntando una tras otra aunque tenga un igr diferente o creo una variable diferente para cada una, por ejemplo

HE$ todo lo que tiene en igr: 20205
HE1$ todo lo que tiene en igr: 344

o

HE$="igr:20205+igr:344+igr:384"

despues lo mismo con ts_pong???

gracias

[xt5]

Me perdí un poco con lo que pones dogdark, creo que me falta contexto.
Definir esa estructura de datos con BASIC no es difícil, aunque los datos grandes yo los pondría en un archivo en un diskette y utilizando en el token DATA definiría los valores de IRG y cuanto mide el bloque.

Explayate un poco mas sobre que quieres conseguir y si es con algo de código, mejor.

[dogdark]

a ver si hasta yo me perdi, jajajaj
te explico como lo quiero hacer en basic

Código: Seleccionar todo

10 GR.0:POKE 710,0
100 DIM HE$(396)
200 HE$="UU7754Bvhy" : REM ACA VA LOS HEXADECIMALES 55,55,FA,00 del ts_header igr 20205 POR SUPUESTO INGRESADOS TODOS
210 S=LEN(HE$)+1
220 HE$(S)="UU76HNDTEE" : REM ACA VAN TODOS LOS HEXA 55,55,FC,01 DEL ts_header igr 344 
230 S=LEN(HE$)+1
240 HE$(S)="UUYYEHGD" : REM ACA VAN TODOS LOS HEXA 55,55,FE,00 DEL ts_header igr 384

lo que demuestro en el primero es la sumatoria de todos los igr en una sola variable ooo tendria que hacerlo asi

Código: Seleccionar todo

10 GR.0:POKE 710,0
100 DIM HE$(396)
200 HE$="UU7754Bvhy" : REM ACA VA LOS HEXADECIMALES 55,55,FA,00 del ts_header igr 20205 POR SUPUESTO INGRESADOS TODOS
220 HE1$="UU76HNDTEE" : REM ACA VAN TODOS LOS HEXA 55,55,FC,01 DEL ts_header igr 344 
230 HE2$(S)="UUYYEHGD" : REM ACA VAN TODOS LOS HEXA 55,55,FE,00 DEL ts_header igr 384

esto es para pasar los codigos y como tengo que hacerlo asi lo subo para poder seguir con el proyecto del copiador, yo me doy la paja de digitar todo.

como en el primero me sale 0x55, yo elimino el 0x y dejo los dos ultimos y seria 55 y segun manual atari el 55 representa la letra U, el FA es una z en inverso, el 00 es un corazon, estoy bien o no asi????

y al ts_pong le doy la variable pon$

[xt5]

como en el primero me sale 0x55, yo elimino el 0x y dejo los dos ultimos y seria 55 y segun manual atari el 55 representa la letra U, el FA es una z en inverso, el 00 es un corazon, estoy bien o no asi????

Está bien este razonamiento, y la primera forma a simple vista se ve correcta, pero me surge una duda: como se escapan las comillas (") en un string de BASIC, tarde o temprano te saldrá una y tienes que saber como enfrentarlo.

Por otro lado, tipear todo eso a mano es inhumano, o lo cargas de un archivo o te hacer alguna especie de generador

[fcatrin]

Está bien este razonamiento, y la primera forma a simple vista se ve correcta, pero me surge una duda: como se escapan las comillas (") en un string de BASIC, tarde o temprano te saldrá una y tienes que saber como enfrentarlo.

"ABC" + CHR$(32) + "DEF"

Por otro lado, tipear todo eso a mano es inhumano, o lo cargas de un archivo o te hacer alguna especie de generador

+1

[vitoco]

Está bien este razonamiento, y la primera forma a simple vista se ve correcta, pero me surge una duda: como se escapan las comillas (") en un string de BASIC, tarde o temprano te saldrá una y tienes que saber como enfrentarlo.

"ABC" + CHR$(32) + "DEF"

Por otro lado, tipear todo eso a mano es inhumano, o lo cargas de un archivo o te hacer alguna especie de generador

+1

El caracter de la comilla es el 34, y el de fin de línea el 155. Esos són los únicos caracteres que no se pueden meter en un string en forma directa.

Para resolver eso, hice un programilla hace aaaaaaños: STRING.BAS

Spoiler: MOSTRAR

Con él generaba trozos de programa en formato .LST a partir de un archivo binario .OBJ recién ensamblado, y con ENTER lo agregaba al programa BASIC que estaba creando.

Este programa se come los 6 primeros bytes del archivo ensamblado porque son cabecera (ver línea 410), y asume que todo los demás va a ir a dar a una variable string, por lo tanto hay que tener cuidado con MAC65, ya que ese ensamblador genera trozos de 256 bytes en el .OBJ, intercalando nuevas cabeceras para el siguiente bloque, lo que este programa no considera... es que no eran relevantes los punteros a memoria de los binarios.

Si el archivo binario lo quieres meter completito a un string, hay que eliminar esos 6 GET desde la línea 410.

[dogdark]

efectivamente el codigo lo escribo a mano, caracter por caracter, a mi me gusta escribir y darme esas tremendas pajas, jajajjajja y las (") como preguntabas xt5 lo hago de dos maneras como lo dijo franco, o ocupo el programa el traductor, con eso cambio el caracter que lo dejo con espacio en blanco y le coloco el ("), lo que dice vitoco tambien es utilizable, pero yo no lo entendi, zorry vitoco, ¿como lo hago? como funciona, siempre e escrito el codigo a mano, por carecer de conocimientos respecto a assembler y transformacion de binarios. por eso ofreci escribir el código, después lo subo y seguimos con el copiador. si hay alguna otra propuesta se acepta de todos modos, aaaa franco, revise tu copiador cain II, y es muy similar al turbo software, tiene tambien 3 etapas de carga.

[xt5]

Hice una pequeña maqueta de como se podría hacer un cargador sencillo en BASIC, la idea es evitar hacer el ingreso a mano, sinceramente no entiendo como a dogdark le puede gustar!!!

Primero, en el PC, con Python, genero un blob grande con todos los sectores concatenados, y a la par una lista "DATA" de los IRG y el tamaño de cada bloque.

Código: Seleccionar todo

import sys, struct
import turbo_data

sys.stdout.write("DATA ")

f=open("cargador","wb")
for d in turbo_data.ts_header:
	f.write(struct.pack("B"*len(d["data"]), *d["data"]))
	sys.stdout.write("%d,%d," % (len(d["data"]), d["igr"]))

for d in turbo_data.ts_pong:
	f.write(struct.pack("B"*len(d["data"]), *d["data"]))
	sys.stdout.write("%d,%d," % (len(d["data"]), d["igr"]))

sys.stdout.write("-1,-1")

Luego en el Atari leo el blob completo en la memoria, recorro la lista obteniendo el IRG y largo de cada sector, y vuelco los primeros 16 bytes en la pantalla. Para hacer el cargador en vez de volcar los datos a pantalla se deberían grabar al cassette, en la llamada a la subrutina que está en la posición 600 tenemos todo lo necesario: dirección donde empiezan los datos, largo del sector e IRG.

Código: Seleccionar todo

10 DIM N$(16):N$="0123456789ABCDEF"
20 ADDR=24576
30 LENGHT=3594
40 DIM NAME$(10):NAME$="D:CARGADOR"
50 GOSUB 500
60 OFFSET=ADDR
70 READ SZ, IGR
71 PRINT IGR;" ";SZ
80 IF SZ=-1 THEN GOTO 120
90 GOSUB 600
100 OFFSET=OFFSET+SZ
110 GOTO 70
120 PRINT "OK"
121 STOP
130 DATA 132,20205,132,344,132,384,571,349,1019,787,134,4214,134,114,134,97
131 DATA 134,112,134,123,134,114,134,98,134,110,134,113,134,104,134,122,134,163,-1,-1

500 REM CARGA ARCHIVO NAME$,
501 REM DE LARGO LENGHT EN ADDR 
510 OPEN #1,4,0,NAME$
520 H=INT(ADDR/256):L=ADDR-(H*256)
530 POKE 852+1,H:POKE 852,L
540 H=INT(LENGHT/256):L=LENGHT-(H*256)
550 POKE 856+1,H:POKE 856,L
560 POKE 850,7:A=USR(ADR("hhh*LVd"),16)
570 CLOSE #1
580 RETURN

600 REM IMPRIME EN PANTALLA LOS 
601 REM PRIMEROS 16 BYTES DE OFFSET
610 FOR I=0 TO 15
620 A=PEEK(OFFSET+I)
630 B=INT(A/16)
640 C=A-(B*16)
650 PRINT N$(B+1,B+1);N$(C+1,C+1);
660 NEXT I
670 PRINT ""
680 RETURN

Franco y vitoco dijeron que la llamada estandar al CIO no bastaba para grabar estos sectores customs, así que el siguiente paso me imagino que es solventar eso.

[vitoco]

lo que dice vitoco tambien es utilizable, pero yo no lo entendi, zorry vitoco, ¿como lo hago? como funciona, siempre e escrito el codigo a mano, por carecer de conocimientos respecto a assembler y transformacion de binarios.

Supongamos que tienes en tu ATR un archivo llamado D:ETAPA1.DAT que contiene el loader, incluyendo el "UU" (0x55 0x55) del comienzo, sin cabeceras binarias de los XEX,, entonces:

1. Meter STRING.BAS en el mismo ATR.
2. Cargar ATR en el Atari BASIC con: LOAD "D:STRING.BAS"
3. Borrar las líneas 410, 420 y 430 asociadas a las cabeceras.
4. Correr el conversor con RUN
5. A la pregunta del archivo origen, responder: D:ETAPA1.DAT
6. Para el destino, responder: D:ETAPA1.LST
7. Para el nombre de la variable, responder: ETAPA1
8. Para el número de línea: 1000 (o el número de línea donde quieras dejar el string)
9. Para el incremento: 1
10. Al cabo de unos segundos, tendrás un archivo llamado D:ETAPA1.LST en tu ATR.
11. Cargar tu programa BASIC con LOAD "D:GRABADOR".
12. Agregarle la(s) nueva(s) línea(s) con: ENTER "D:ETAPA1.LST"
13. Si revisas tu programa con LIST, tendrás unas nuevas líneas que dicen algo así como:

Código: Seleccionar todo

1000 ETAPA1$="UUxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx..."
1001 ETAPA1$(81)="xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx..."
1002 ETAPA1$(20,20)=CHR(34)

14. Obviamente hay que poner un DIM ETAPA1$(nnn) con el tamaño apropiado donde corresponda.

¿Se entendió?

[fcatrin]

La rutina de grabación se puede ver acá:

https://www.dropbox.com/sh/d3091cy8vn02lw9/m9c_0efvZc

Es el CAIN.BIN.TXT

Publicado "As Is"