Rise of the Triad AGA

[lantus360]

Coming real soon now fellas .

[Bamiga2002]

Classic game !

[meckert]

Can't wait.... Will it support gfx card modes ?

[lantus360]

right now its supports AGA and ECS (64 color EHB mode) - gfx card support will come in a future build.

cheers

edit: uploaded a video of latest progress - [ Show youtube player ]

[HardStep]

Is it going to say "Buy a 486!" when you resize the screen to a postmark?

Great game and nice work

[lantus360]

haha it still does. but i can change it

any ideas?

[Muzkat]

Looks rad. Well done matey.

[lantus360]

so after a bit of hacking, I added RTG support. It will come in the first release after all

[meckert]

Originally Posted by lantus360

so after a bit of hacking, I added RTG support. It will come in the first release after all

Cool. A lot of new stuff for ami 68k lately.

[NovaCoder]

Originally Posted by lantus360

so after a bit of hacking, I added RTG support. It will come in the first release after all

Cool, looking good

I could prob give you a hand with the RTG and ECS code, post some code to this thread and I'll have a look.

Are you using the CyberGFX API for RTG?

[duga]

Originally Posted by lantus360

haha it still does. but i can change it

any ideas?

"Buy a 060!"

[NovaCoder]

Originally Posted by duga

"Buy a 060!"

+2

[corpsicle]

Originally Posted by duga

"Buy a 060!"

This!

[Bamiga2002]

"Buy a Natami!" ??

[Steve]

"Buy an Intel Core i7!"

[NovaCoder]

This is my latest DOOM sound engine interface code, seems to work really nicely.

PHP Code:

#include <stdio.h>
#include <stdlib.h>
#include <stdarg.h>

#include "doomdef.h"
#include "doomtype.h"
#include "m_alloc.h"


#include "wave.h"
#include "m_swap.h"
#include "z_zone.h"

#include "c_cvars.h"
#include "i_system.h"
#include "i_sound.h"
#include "i_music.h"
#include "m_argv.h"
#include "m_misc.h"
#include "w_wad.h"
#include "i_video.h"
#include "s_sound.h"


// Amiga includes.
#include <proto/exec.h>

#include "amiga_sound_library.h"


#define MAX_AMIGA_CHANNELS  16

#define AMIGA_NORMAL_SEP 128
#define AMIGA_MAX_SFX_VOLUME 128
#define AMIGA_MAX_MUSIC_VOLUME 64


// killough 2/21/98: optionally use varying pitched sounds
CVAR (snd_pitched, "0", CVAR_ARCHIVE)
#define PITCH(f,x) (snd_pitched.value ? ((f)*(x))/128 : (f))

static struct Library *DoomSndBase = NULL;

static int no_music = 0;
static int no_sfx = 0;
static float vol_sfx = 0;






void I_InitSound (void)
{
    no_sfx = (!!Args.CheckParm ("-nosfx") || !!Args.CheckParm ("-nosound"));

    no_music = (!!Args.CheckParm("-nomusic") || !!Args.CheckParm("-nosound"));
    
    if (no_sfx && no_music) {
        return;
    }
    

    DoomSndBase = (struct Library *)OpenLibrary ("doomsound.library", 37);
    if (!DoomSndBase) {
        I_Error("Could not open doomsound.library!");
    }


    // Finished initialization.
    Printf (PRINT_HIGH, "Sound Module ready....\n");
}

void I_ShutdownSound (void)
{
    int i;

    if (no_sfx && no_music) {
        return;
    }


    // [RH] Free all loaded samples
    for (i = 0; i < numsfx; i++)
    {
        if (!S_sfx[i].link)
        {
            if (S_sfx[i].data)
            {
                free (S_sfx[i].data);
            }
        }

        S_sfx[i].data = S_sfx[i].link = NULL;
    }


    if (DoomSndBase != NULL) {
        CloseLibrary(DoomSndBase);
        DoomSndBase = NULL;
    }
}


static void getsfx (sfxinfo_t *sfx)
{
    char                sndtemp[128];
    unsigned char        *sfxdata;
    unsigned char        *sfxcopy;
    int                 size;
    int                    i;
    int                    s,d;
    

    // Get the sound data from the WAD

    // If the sound doesn't exist, try a generic male sound (if this is a player sound) or the empty sound.
    if (sfx->lumpnum == -1) {
        char *basename;
        int sfx_id;

        if (!strnicmp (sfx->name, "player/", 7) && (basename = strchr (sfx->name + 7, '/'))) {
            sprintf (sndtemp, "player/male/%s", basename+1);
            sfx_id = S_FindSound (sndtemp);
            if (sfx_id != -1)
                sfx->lumpnum = S_sfx[sfx_id].lumpnum;
        }

        if (sfx->lumpnum == -1)
badwave:
            sfx->lumpnum = W_GetNumForName ("dsempty");
    }
    
    // See if there is another sound already initialized with this lump. If so,
    // then set this one up as a link, and don't load the sound again.
    for (i = 0; i < numsfx; i++)
        if (S_sfx[i].data && !S_sfx[i].link && S_sfx[i].lumpnum == sfx->lumpnum) {
            DPrintf ("Linked to %s (%d)\n", S_sfx[i].name, i);
            sfx->link = S_sfx + i;
            sfx->ms = S_sfx[i].ms;
            sfx->data = S_sfx[i].data;
            sfx->normal = S_sfx[i].normal;
            sfx->looping = S_sfx[i].looping;
            return;
        }

    size = W_LumpLength (sfx->lumpnum);
    if (size == 0) {
        goto badwave;
    }
        

    sfxdata = (unsigned char *)W_CacheLumpNum(sfx->lumpnum, PU_CACHE);


    if (LONG_SWAP(*((unsigned int *)sfxdata)) == ID_RIFF) {
        // RIFF WAVE sound
        I_Error("RIFF WAVE sound detected");
    } else {
        // DMX sound
        //DPrintf ("DMX sound detected\n");
        

        sfx->frequency = SHORT_SWAP(((short *)sfxdata)[1]);
        //sfx->frequency = (unsigned int)snd_samplerate.value;
        
        
        sfx->length = (size - 8);
        
        //DPrintf ("getsfx() - sfx->frequency = %d\n", sfx->frequency);
        //DPrintf ("getsfx() - sfx->length = %d\n", sfx->length);    
    }

    sfxcopy = (unsigned char *)Malloc(size);
    
    
    // Now copy and pad.
    s = 1;
    for (d = 0; d < size; d++) {
        sfxcopy[d] = sfxdata[s] ^ 0x80;
        
        s++;    
    }
    
    Z_Free (sfxdata);

        
    sfx->ms = (sfx->length * 1000) / (sfx->frequency);
    sfx->data = sfxcopy;
}



//
// SFX API
//
void I_SetChannels (int numchannels)
{
    // Not needed. 
}

 
void I_SetSfxVolume (int volume)
{
    if (no_sfx) {
        return;
    }

    vol_sfx = (float)((volume / 15.0) * (256.0 / 255.0));    
}


//
// Starting a sound means adding it
//        to the current list of active sounds
//        in the internal channels.
// As the SFX info struct contains
//        e.g. a pointer to the raw data,
//        it is ignored.
//
int I_StartSound(sfxinfo_t *sfx, int vol, int sep, int pitch, ZDOOM_BOOL looping)
{
    static int handle = 0;
    int volume;
    
    if (no_sfx) {
        return 0;
    }    
    
    handle++;
    if (handle >= MAX_AMIGA_CHANNELS) {
        handle = 0;
    }
    
    volume = ((int)(vol * vol_sfx))/2;   /* original range 0-255, AMIGA range 0-128 */
    
    if ( volume > AMIGA_MAX_SFX_VOLUME ) volume = AMIGA_MAX_SFX_VOLUME;
    else if ( volume < 0 ) volume = 0;    
    

    //DPrintf ("I_StartSound() - sfx->name = %s\n", sfx->name);
    //DPrintf ("I_StartSound() - sfx->frequency = %d\n", sfx->frequency);
    //DPrintf ("I_StartSound() - sfx->length = %d\n", sfx->length);
    //DPrintf ("I_StartSound() - vol = %d\n", vol);
    //DPrintf ("I_StartSound() - volume = %d\n", volume);
    //DPrintf ("I_StartSound() - vol_hacked = %d\n", vol >> 1);        
    //DPrintf ("I_StartSound() - sep = %d\n", sep);    
    
    if (sep < 0) {
        sep = AMIGA_NORMAL_SEP;
    }

    I_StopSound(handle);
    
    Sfx_Start((char *)sfx->data, handle, PITCH(sfx->frequency, pitch), volume, sep, sfx->length);
    
    return handle;
}

void I_StopSound(int handle)
{
    if (no_sfx) {
        return;
    }    
    
    if (I_SoundIsPlaying(handle)) {
        Sfx_Stop(handle);
    }
}


int I_SoundIsPlaying (int handle)
{
    if (no_sfx) {
        return 0;
    }
        
    return Sfx_Done(handle) ? 1 : 0;
}


void I_UpdateSoundParams(int handle, sfxinfo_t *sfx, int vol, int sep, int pitch)
{
    int volume;
    
    if (no_sfx) {
        return;
    }
    
    volume = ((int)(vol * vol_sfx))/2;   /* original range 0-255, AMIGA range 0-128 */
    if ( volume > AMIGA_MAX_SFX_VOLUME ) volume = AMIGA_MAX_SFX_VOLUME;
    else if ( volume < 0 ) volume = 0;    
        
    if (sep < 0) {
        sep = AMIGA_NORMAL_SEP;
    }
    
    if (I_SoundIsPlaying(handle)) {
        Sfx_Update(handle, PITCH(sfx->frequency, pitch), volume, sep);
    }
}


void I_LoadSound (struct sfxinfo_struct *sfx)
{
    if (no_sfx) {
        return;
    }

    if (!sfx->data)
    {
        int i = sfx - S_sfx;
        //DPrintf ("loading sound \"%s\" (%d)\n", sfx->name, i);
        getsfx (sfx);
    }
}



/***********************MUSIC API*********************************************/

int I_RegisterSong (void *data, int musicLen)
{
    int handle = 0;
    int musicType;
    
    if (!no_music) { 
        musicType = LONG_SWAP(*(int *)data);  
        if (musicType == (('M')|(('U')<<8)|(('S')<<16)|((0x1a)<<24))) {        
           // This is a mus file
           handle = Mus_Register(data);
        }
    }
    
    return handle;                  
}

void I_UnRegisterSong (int handle)
{
    if (!no_music) {
        if (handle > 0) {
            Mus_Unregister(handle);
        }
    }
}

void I_PlaySong (int handle, int looping)
{
    if (!no_music) {
        if (handle > 0) {
            Mus_Play(handle, looping);
        }
    }
}


void I_SetMusicVolume (int volume)
{
    //DPrintf ("I_SetMusicVolume(%d)\n", volume);
    
    if (!no_music) {
        if ( volume > AMIGA_MAX_MUSIC_VOLUME ) volume = AMIGA_MAX_MUSIC_VOLUME;
        else if ( volume < 0 ) volume = 0;
        
        
        Mus_SetVol(volume);
        //DPrintf ("I_SetMusicVolume() - volume = %d\n", volume);
    }
}

void I_SetMIDIVolume (float volume)
{
    // Not needed (yet!)
}

void I_PauseSong (int handle)
{
    if (!no_music) {
        if (handle >= 0) {
            Mus_Pause(handle);
        }
    }
}

void I_ResumeSong (int handle)
{
    if (!no_music) {
        if (handle > 0) {
            Mus_Resume(handle);
        }
    }
}

void I_StopSong (int handle)
{
    if (!no_music) {
        if (handle > 0) {
            Mus_Stop(handle);
        }
    }
} 


And this is how I do my input handling these days..

PHP Code:

#include "doomdef.h"
#include "doomtype.h"
#include "c_dispatch.h"
#include "c_console.h"
#include "d_main.h"

#include "i_system.h"
#include "i_input.h"

// Amiga stuff.
#include <proto/exec.h>
#include <proto/intuition.h>
#include <proto/graphics.h>
#include <clib/keymap_protos.h>


#include "amiga_keyboard_codes.h"


/** Global Hardware window */
extern struct Window *_hardwareWindow;



static int keycode_lookup[256];


ZDOOM_BOOL I_InitInput(void) {
    
    int i;


    for (i=0; i<256; i++) {
        keycode_lookup[i] = 0;
    }


    // Top row
    keycode_lookup[RAWKEY_ESCAPE] = KEY_ESCAPE;
    keycode_lookup[RAWKEY_F1] = KEY_F1;
    keycode_lookup[RAWKEY_F2] = KEY_F2;
    keycode_lookup[RAWKEY_F3] = KEY_F3;
    keycode_lookup[RAWKEY_F4] = KEY_F4;
    keycode_lookup[RAWKEY_F5] = KEY_F5;
    keycode_lookup[RAWKEY_F6] = KEY_F6;
    keycode_lookup[RAWKEY_F7] = KEY_F7;
    keycode_lookup[RAWKEY_F8] = KEY_F8;
    keycode_lookup[RAWKEY_F9] = KEY_F9;
    keycode_lookup[RAWKEY_F10] = KEY_F10;
    keycode_lookup[RAWKEY_F11] = KEY_F11;
    keycode_lookup[RAWKEY_F12] = KEY_F12;


    // Second row
    keycode_lookup[RAWKEY_TILDE] = 41;
    keycode_lookup[RAWKEY_1] = 2;
    keycode_lookup[RAWKEY_2] = 3;
    keycode_lookup[RAWKEY_3] = 4;
    keycode_lookup[RAWKEY_4] = 5;
    keycode_lookup[RAWKEY_5] = 6;
    keycode_lookup[RAWKEY_6] = 7;
    keycode_lookup[RAWKEY_7] = 8;
    keycode_lookup[RAWKEY_8] = 9;
    keycode_lookup[RAWKEY_9] = 10;
    keycode_lookup[RAWKEY_0] = 11;
    keycode_lookup[RAWKEY_MINUS] = KEY_MINUS;
    keycode_lookup[RAWKEY_EQUAL] = KEY_EQUALS;
    keycode_lookup[RAWKEY_BACKSLASH] = 43;
    keycode_lookup[RAWKEY_BACKSPACE] = KEY_BACKSPACE;



    // Third row.
    keycode_lookup[RAWKEY_TAB] = KEY_TAB;
    keycode_lookup[RAWKEY_Q] = 16;
    keycode_lookup[RAWKEY_W] = 17;
    keycode_lookup[RAWKEY_E] = 18;
    keycode_lookup[RAWKEY_R] = 19;
    keycode_lookup[RAWKEY_T] = 20;
    keycode_lookup[RAWKEY_Y] = 21;
    keycode_lookup[RAWKEY_U] = 22;
    keycode_lookup[RAWKEY_I] = 23;
    keycode_lookup[RAWKEY_O] = 24;
    keycode_lookup[RAWKEY_P] = 25;
    keycode_lookup[RAWKEY_LBRACKET] = 26;
    keycode_lookup[RAWKEY_RBRACKET] = 27;


    // Fourth row.
    keycode_lookup[RAWKEY_LCONTROL] = KEY_LCTRL;
    keycode_lookup[RAWKEY_A] = 30;
    keycode_lookup[RAWKEY_S] = 31;
    keycode_lookup[RAWKEY_D] = 32;
    keycode_lookup[RAWKEY_F] = 33;
    keycode_lookup[RAWKEY_G] = 34;
    keycode_lookup[RAWKEY_H] = 35;
    keycode_lookup[RAWKEY_J] = 36;
    keycode_lookup[RAWKEY_K] = 37;
    keycode_lookup[RAWKEY_L] = 38;
    keycode_lookup[RAWKEY_SEMICOLON] = 39;
    keycode_lookup[RAWKEY_RETURN] = KEY_ENTER;

    

    // Fifth row.
    keycode_lookup[RAWKEY_LSHIFT] = KEY_LSHIFT;
    keycode_lookup[RAWKEY_Z] = 44;
    keycode_lookup[RAWKEY_X] = 45;
    keycode_lookup[RAWKEY_C] = 46;
    keycode_lookup[RAWKEY_V] = 47;
    keycode_lookup[RAWKEY_B] = 48;
    keycode_lookup[RAWKEY_N] = 49;
    keycode_lookup[RAWKEY_M] = 50;
    keycode_lookup[RAWKEY_COMMA] = 51;
    keycode_lookup[RAWKEY_PERIOD] = 52;
    keycode_lookup[RAWKEY_SLASH] = 53;
    keycode_lookup[RAWKEY_RSHIFT] = KEY_RSHIFT;


    // Sixth row.
    keycode_lookup[RAWKEY_LALT] = KEY_LALT;
    keycode_lookup[RAWKEY_SPACE] = KEY_SPACE;
    keycode_lookup[RAWKEY_RALT] = KEY_RALT;
       
    
    // Middle column.
    keycode_lookup[RAWKEY_DELETE] = KEY_DEL;
    keycode_lookup[RAWKEY_UP] = KEY_UPARROW;
    keycode_lookup[RAWKEY_LEFT] = KEY_LEFTARROW;
    keycode_lookup[RAWKEY_DOWN] = KEY_DOWNARROW;
    keycode_lookup[RAWKEY_RIGHT] = KEY_RIGHTARROW;


    // Keypad 0-9
    keycode_lookup[RAWKEY_KP_7] = 71;
    keycode_lookup[RAWKEY_KP_8] = 72;
    keycode_lookup[RAWKEY_KP_9] = 73;
    keycode_lookup[RAWKEY_KP_4] = 75;
    keycode_lookup[RAWKEY_KP_5] = 76;
    keycode_lookup[RAWKEY_KP_6] = 77;
    keycode_lookup[RAWKEY_KP_1] = 79;                  
    keycode_lookup[RAWKEY_KP_2] = 80;
    keycode_lookup[RAWKEY_KP_3] = 81;
    keycode_lookup[RAWKEY_KP_0] = 82;
    keycode_lookup[RAWKEY_KP_DECIMAL] = 83;
    keycode_lookup[RAWKEY_KP_ENTER] = 156;

        
    return true;
}

void I_ShutdownInput(void) {
    // Nothing to do...   
}


void I_GetEvent(void) {

    event_t event;
    int code;
    int qual;
    int mousex, mousey;
    struct IntuiMessage *imsg;
    
    // Setup.
    event.data1 = event.data2 = event.data3 = 0;
 

    if (_hardwareWindow != NULL) {
        while (imsg = (struct IntuiMessage *)GetMsg(_hardwareWindow->UserPort)) {

            ReplyMsg((struct Message *)imsg);

            code = imsg->Code;
            qual = imsg->Qualifier;

            switch (imsg->Class) {
                case IDCMP_MOUSEMOVE:
                    event.type = ev_mouse;
                    
                    event.data2 = imsg->MouseX << 2;
                    event.data3 = -imsg->MouseY << 2;
                    
                    D_PostEvent(&event);
                    break;
        
                case IDCMP_MOUSEBUTTONS:
                    event.type = (code & IECODE_UP_PREFIX) ? ev_keyup : ev_keydown;
                    
                    code &= ~IECODE_UP_PREFIX;
                     
                    switch(code)
                    {
                        case IECODE_LBUTTON:
                            event.data1 = KEY_MOUSE1;
                            event.data2 = KEY_MOUSE1;
                            event.data3 = event.data2;
                            
                            D_PostEvent(&event);
                            break;
                
                        case IECODE_MBUTTON:
                            event.data1 = KEY_MOUSE2;
                            event.data2 = KEY_MOUSE2;
                            event.data3 = event.data2;

                            D_PostEvent(&event);
                            break;
                
                        case IECODE_RBUTTON:
                            event.data1 = KEY_MOUSE3;
                            event.data2 = KEY_MOUSE3;
                            event.data3 = event.data2;

                            D_PostEvent(&event);
                            break;
                    }                    
                    break;                
                
                case IDCMP_RAWKEY:
                    event.type = (code & IECODE_UP_PREFIX) ? ev_keyup : ev_keydown;
                    
                    switch (code) {
                        case RAWKEY_NM_WHEEL_UP:
                            event.data1 = KEY_MWHEELUP;
                            D_PostEvent(&event);
                            break;

                        case RAWKEY_NM_WHEEL_DOWN:
                            event.data1 = KEY_MWHEELDOWN;
                            D_PostEvent(&event);
                            break;

                        default:
                            code &= ~IECODE_UP_PREFIX;
                            
                            if (code > 255) {
                                I_Error("Could not translate key, scan-code outside array bounds");
                            }
                            
                            event.data1 = keycode_lookup[code];
                            
                            if (event.data1 != 0) {
                                // We handle this key, now attempt to get an ascii value.
                                char charbuf;
                                InputEvent FakedIEvent;
                                
                                //DPrintf ("IDCMP_RAWKEY, handled Amiga code = %d\n", code);    
                                //DPrintf ("IDCMP_RAWKEY, mapped to keyboard code = %d\n", event.data1);    
                                
                                memset(&FakedIEvent, 0, sizeof(InputEvent));
                                FakedIEvent.ie_Class = IECLASS_RAWKEY;
                                FakedIEvent.ie_Code = code;
                                                      
                                
                                if (MapRawKey(&FakedIEvent, &charbuf, 1, NULL) == 1) {
                                    event.data2 = charbuf;
                                    
                                    //DPrintf ("IDCMP_RAWKEY, ascii code = %d\n", event.data2);
                                    
                                    event.data3 = event.data2;
                                    
                                    if (qual & IEQUALIFIER_LSHIFT || qual & IEQUALIFIER_RSHIFT) {
                                        FakedIEvent.ie_Qualifier = IEQUALIFIER_LSHIFT;
                                        if (MapRawKey(&FakedIEvent, &charbuf, 1, NULL) == 1) {
                                            event.data3 = charbuf;
                                        }
                                    }
                                }
                                
                                D_PostEvent(&event);
                            }
                            break;
                    }
            }
        }
    }
} 


Might give you some ideas

[lantus360]

thanks Nova, ill take a peek and see if i can use any of that code.

ROTT sound core is strange . Unlike the Doom games, it used VOC audio files rather than raw audio/WAVs inside its WAD file. I started out writing a VOC decoder, but it used up way too many cpu cycles. As a result im going to supply a PPF or IPS file to patch the original wad to a modified one that is friendly with the Amiga. The patch will patch all the vocs->raw

Im noticing sound is "dissappearing" during gameplay, but im sure its something minor.

As far as RTG goes yep, im using CGX API. Right now its fixed at 320x200 (like the AGA and ECS builds) for the first release. It may change going forward

[NovaCoder]

Originally Posted by lantus360

thanks Nova, ill take a peek and see if i can use any of that code.

ROTT sound core is strange . Unlike the Doom games, it used VOC audio files rather than raw audio/WAVs inside its WAD file. I started out writing a VOC decoder, but it used up way too many cpu cycles. As a result im going to supply a PPF or IPS file to patch the original wad to a modified one that is friendly with the Amiga. The patch will patch all the vocs->raw
As far as RTG goes yep, im using CGX API. Right now its fixed at 320x200 (like the AGA and ECS builds) for the first release. It may change going forward

Yep pre-converting is always the best way to go with 68k, you need every cycle you can get



I think this is the fastest way to update the screen with CGX

PHP Code:

void I_FinishUpdate(void)
{
    APTR video_bitmap_handle = NULL;
    UBYTE *base_address = NULL;
    
    // Check whether the palette was changed.
    if (_paletteDirty) {
        LoadRGB32(&_hardwareScreen->ViewPort, _agaPalette);

        // Reset.
        _paletteDirty = FALSE;
    }
    
    
    video_bitmap_handle = LockBitMapTags(_hardwareScreen->ViewPort.RasInfo->BitMap,
                                         LBMI_BASEADDRESS, (ULONG)&base_address,
                                         TAG_DONE);                                         
    if (video_bitmap_handle) {
        CopyMemQuick(screen->buffer, base_address, (screen->width * screen->height));
    UnLockBitMap (video_bitmap_handle);
    video_bitmap_handle = NULL;
    }    
} 


[lantus360]

thats exactly how im updating CGX

thanks for the tips!

[lantus360]

i know ive said this before but this should be done and released this weekend

fixed all outstanding issues, just trying to tweak performance a little

AGA/ECS/RTG supported in the first version

ive got an Indivision ECS on the way also and will add chunky mode in a future build