/*
     Ghost In The Machine 
     main.c
*/

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

#include <exec/types.h>
#include <exec/memory.h>
#include <proto/graphics.h>
#include <proto/exec.h>
#include <utility/hooks.h>

#include "VA3d:VA3D_Structures.h"
#include "va3d:VA3D_animation.h"
#include "va3d:VA3D_Display.h"
#include "va3d:VA3D_entity.h"
#include "va3d:VA3D_globalvar.h"
#include "va3d:VA3D_io.h"
#include "va3d:VA3D_map.h"
#include "va3d:VA3D_precalc.h"
#include "va3d:VA3D_palette.h"
#include "va3d:VA3D_render.h"
#include "va3d:VA3D_scene.h"
#include "va3d:VA3D_Timer.h"
#include "va3d:VA3D_xview.h"

#include "ShowPicture/Show_Pic.h"
#include "MusicPlayer/Music_Play.h"
#include "XPK/XPK_Reader.h"

LONG __near __stack = 20*1024;

ULONG __saveds __asm RenderFrameHook(REGISTER __a0 struct Hook *hook,
						       REGISTER __a2 APTR object,
 						       REGISTER __a1 APTR message);
ULONG __saveds __asm RenderQuakeFrameHook(REGISTER __a0 struct Hook *hook,
						       REGISTER __a2 APTR object,
 						       REGISTER __a1 APTR message);
ULONG __saveds __asm PaletteHookFunc(REGISTER __a0 struct Hook *hook,
						       REGISTER __a2 APTR object,
 						       REGISTER __a1 APTR message);

ENTITY *FindEntity(ENTITY *Entity, STRPTR Name);

VOID CleanUp(VOID);
VOID FillPKeyEntry(PKEY_FRAME *CurrentKey,PKEY_FRAME *NextKey,PALETTE *Palette,ULONG Time,ULONG Flags);
struct Hook RenderHook;
struct Hook PalHook;

typedef struct Scene_2
          {
          SCENE *Scene;
          PALETTE *Palette;
          }SCENE_2;

SCENE_2 *LoadAndRelocScene(STRPTR SceneName,STRPTR PaletteName);
VOID FreeScene(SCENE_2 *Scene);

#define VALUES_NUMBER 4096
#define ANGLES_NUMBER 360
#define VISIBLE_ANGLE 40
VOID *KatowiceChunky;
VOID *KatowicePalette;
VOID *NoiseChunky;
VOID *NoisePalette;
VOID *Bump_ShineLUT;
VOID *EndChunky;
VOID *EndPalette;
SCENE_2 *IntroScene;
SCENE_2 *GhostScene;
SCENE_2 *BabeScene;
SCENE_2 *RolloScene;
SCENE_2 *BumpScene;
SCENE_2 *QuakeScene;
SCENE_2 *CreditsScene;
SCENE_2 *DragonScene;
SCENE_2 *VA3DLogoScene;

PALETTE *BlackPal;
PALETTE *WhitePal;
PALETTE *RedPal;
PALETTE *BluePal;

ULONG CurrentTime;

DVIEW *DView=NULL;

#define SEC 709379

PKEY_FRAME PKey[7];

ULONG DragonFly[] =
{
	0, 1, 2, 3, 4, 5, 6, 7, 6, 5, 4, 3, 2, 1
};

ULONG SoldierRun[] =
{
	73, 74, 75, 76, 77, 78, 79, 80
};

ULONG DogRun[] =
{
	48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59
};

ULONG SoldierStand_Load_Shoot[] =
{
	//0, 1, 2, 3, 4, 5, 6, 7,
  29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39,
  81, 82, 83, 84, 85, 86, 87, 88, 89, 0, 1, 2, 3, 4, 5, 6, 7, 0, 1, 2,
  3, 4, 5, 6, 7, 0, 1, 2, 3, 4, 5, 6, 7, 0, 1, 2, 3, 4, 5, 6, 7, 0, 1,
  2, 3, 4, 5, 6, 7
};

ULONG DogStand_Pain[] =
{
	//69, 70, 71, 72, 73, 74, 75, 76,
  77, 69 ,70, 71, 72, 73, 74, 75, 76, 77,
  69, 70, 71,
  32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 17, 18,
  19, 20, 21, 22, 23, 24, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25,
  25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25
};


MORPH_OBJECT *SoldierMObject;
MORPH_OBJECT *DogMObject;
MORPH_OBJECT *DragonMObject;


VOID main(int argc,char **argv)
{
 LONG i;
 BlackPalette[0] = 0x01000000;
 WhitePalette[0] = 0x01000000;
 RedPalette[0]   = 0x01000000;
 BluePalette[0]   = 0x01000000;

     for(i=0;i<256;i++)
      {
        WhitePalette[3*i+1] = (ULONG)255<<24;
        WhitePalette[3*i+2] = (ULONG)255<<24;
        WhitePalette[3*i+3] = (ULONG)255<<24;
        RedPalette[3*i+1] = (ULONG)255<<24;
        RedPalette[3*i+2] = (ULONG)0<<24;
        RedPalette[3*i+3] = (ULONG)0<<24;
        BluePalette[3*i+1] = (ULONG)0<<24;
        BluePalette[3*i+2] = (ULONG)0<<24;
        BluePalette[3*i+3] = (ULONG)255<<24;
      }

  RenderHook.h_Entry = (HOOKFUNC)RenderFrameHook;
  PalHook.h_Entry = (HOOKFUNC)PaletteHookFunc;

  if(!XPK_Init())
     {
          CleanUp();
     }

  VA3D_InitFFBPpower2();

  if((VA3D_RotateTable = XPK_UnPackFile("Data/Rotate.table")) == NULL) CleanUp();

	VA3D_AnglesNumber = (LONG)ANGLES_NUMBER;
	VA3D_CoordsNumber = (LONG)VALUES_NUMBER;
	VA3D_MinCoord = -(LONG)VALUES_NUMBER/2;
	VA3D_MaxCoord = -VA3D_MinCoord-1;
	VA3D_RotateTableCos = &VA3D_RotateTable[VALUES_NUMBER*(ANGLES_NUMBER/4)];

	if(!VA3D_PrecalcArcSineTable())
	{
          CleanUp();
	}

 if(AvailMem(MEMF_CHIP) < 900000) 
     {
          printf ("Not enough chip mem\n");
          CleanUp();
     }

 if(VA3D_InitGFX())
  {
   if(!VA3D_PrecalcPerspectiveTable(VISIBLE_ANGLE,GlobalWidth,VALUES_NUMBER))
	{
          CleanUp();
	}

   if((IntroScene = LoadAndRelocScene("Data/IntroScene.va3d","Data/Venus.palette")) == NULL) CleanUp();

   if((BlackPal = VA3D_AllocPalette(VA3DAP_RGB32,BlackPalette,
                                      VA3DAP_CreateHashTable,FALSE,
                                      TAG_DONE)) == NULL) CleanUp();

   if((WhitePal = VA3D_AllocPalette(VA3DAP_RGB32,WhitePalette,
                                      VA3DAP_CreateHashTable,FALSE,
                                      TAG_DONE)) == NULL) CleanUp();

   if((RedPal = VA3D_AllocPalette(VA3DAP_RGB32,RedPalette,
                                      VA3DAP_CreateHashTable,FALSE,
                                      TAG_DONE)) == NULL) CleanUp();

   if((BluePal = VA3D_AllocPalette(VA3DAP_RGB32,BluePalette,
                                      VA3DAP_CreateHashTable,FALSE,
                                      TAG_DONE)) == NULL) CleanUp();

   if((DView=VA3D_OpenView(BlackPalette,DVF_DBUFF)) == NULL)
     {
          printf("Cannot Open Screen\n");
          CleanUp();
     }
   RenderHook.h_Data = DView;
   PalHook.h_Data = DView;

  if((VA3D_ShineLUT = XPK_UnPackFile("Data/Venus.ShinePalette")) == NULL) CleanUp();

       FillPKeyEntry(&PKey[0],&PKey[1],BlackPal,0,0);
       FillPKeyEntry(&PKey[1],&PKey[2],IntroScene->Palette,2*SEC,PKFF_INTERPOLATE);
       FillPKeyEntry(&PKey[2],NULL,IntroScene->Palette,15*SEC,PKFF_NOINTERPOLATE);

   if(!StartMusic(IntroTuneP61)) CleanUp();
     {
          VA3D_AnimSequence(IntroScene->Scene,
                            VA3DAS_PKeyFrames,&PKey,
                            VA3DAS_PaletteHook,&PalHook,
                            VA3DAS_TimerHook,&TimerHook,
                            VA3DAS_RenderHook,&RenderHook,
                            TAG_DONE);
                    
          StopMusic();
          free(VA3D_ShineLUT);
          memcpy(tmpPal,IntroScene->Palette->RGB32,3080);
          FreeScene(IntroScene);
     }
     
     if((GhostScene=LoadAndRelocScene("Data/GhostScene.va3d","Data/Ghost.palette")) == NULL) CleanUp();
     if((BabeScene=LoadAndRelocScene("Data/BabeScene.va3d","Data/Ghost.palette")) == NULL) CleanUp();
     if((BumpScene=LoadAndRelocScene("Data/BumpScene.va3d","Data/Bump.palette")) == NULL) CleanUp();
     if((QuakeScene=LoadAndRelocScene("Data/Quake2.va3d","Data/Quake.palette")) == NULL) CleanUp();
     if((KatowiceChunky = XPK_UnPackFile("Data/Katowice.chunky")) == NULL) CleanUp();
     if((KatowicePalette = XPK_UnPackFile("Data/Katowice.palette")) == NULL) CleanUp();
     if((Bump_ShineLUT = XPK_UnPackFile("Data/Bump.ShinePalette")) == NULL) CleanUp();
     if((VA3D_ShineLUT = XPK_UnPackFile("Data/Quake.ShinePalette")) == NULL) CleanUp();

     FadeOutPalette(DView,tmpPal,0L,0L,0L,2*SEC);

    if(!StartMusic(MainTuneP61)) CleanUp();

          FillPKeyEntry(&PKey[0],&PKey[1],BlackPal,0,0);
          FillPKeyEntry(&PKey[1],&PKey[2],GhostScene->Palette,2*SEC,PKFF_INTERPOLATE);
          FillPKeyEntry(&PKey[2],NULL,GhostScene->Palette,30*SEC,PKFF_NOINTERPOLATE);
          VA3D_AnimSequence(GhostScene->Scene,
                            VA3DAS_PKeyFrames,&PKey,
                            VA3DAS_PaletteHook,&PalHook,
                            VA3DAS_TimerHook,&TimerHook,
                            VA3DAS_RenderHook,&RenderHook,
                            TAG_DONE);
     
          FillPKeyEntry(&PKey[0],&PKey[1],WhitePal,0,0);
          FillPKeyEntry(&PKey[1],&PKey[2],GhostScene->Palette,2*SEC,PKFF_INTERPOLATE);
          FillPKeyEntry(&PKey[2],NULL,GhostScene->Palette,45*SEC,PKFF_NOINTERPOLATE);
          VA3D_AnimSequence(BabeScene->Scene,
                            VA3DAS_PKeyFrames,&PKey,
                            VA3DAS_PaletteHook,&PalHook,
                            VA3DAS_TimerHook,&TimerHook,
                            VA3DAS_RenderHook,&RenderHook,
                            TAG_DONE);

  RenderHook.h_Entry = (HOOKFUNC)RenderQuakeFrameHook;

          FillPKeyEntry(&PKey[0],&PKey[1],BlackPal,0,0);
          FillPKeyEntry(&PKey[1],&PKey[2],QuakeScene->Palette,2*SEC,PKFF_INTERPOLATE);
          FillPKeyEntry(&PKey[2],NULL,RedPal,36*SEC,PKFF_NOINTERPOLATE);

	SoldierMObject = (MORPH_OBJECT *)FindEntity(QuakeScene->Scene->Entities, "soldier.mdl");
	DogMObject = (MORPH_OBJECT *)FindEntity(QuakeScene->Scene->Entities, "dog.mdl");

	SoldierMObject->Sequence = SoldierRun;
	SoldierMObject->SeqNumber = 8;
	SoldierMObject->CurrentSeq = 0;
	SoldierMObject->SeqDelay = 100000;

	DogMObject->Sequence = DogRun;
	DogMObject->SeqNumber = 12;
	DogMObject->CurrentSeq = 0;
	DogMObject->SeqDelay = 100000;

          VA3D_AnimSequence(QuakeScene->Scene,
                            VA3DAS_PKeyFrames,&PKey,
                            VA3DAS_PaletteHook,&PalHook,
                            VA3DAS_TimerHook,&TimerHook,
														VA3DAS_CurrentTime,&CurrentTime,
                            VA3DAS_RenderHook,&RenderHook,
                            TAG_DONE);

					FadeOutPalette(DView,QuakeScene->Palette->RGB32,255<<24,0L,0L,2*SEC);

		      free(VA3D_ShineLUT);
					VA3D_ShineLUT = Bump_ShineLUT;

	


          RenderHook.h_Entry = (HOOKFUNC)RenderFrameHook;

          FillPKeyEntry(&PKey[0],&PKey[1],RedPal,0,0);
          FillPKeyEntry(&PKey[1],&PKey[2],BumpScene->Palette,2*SEC,PKFF_INTERPOLATE);
          FillPKeyEntry(&PKey[2],&PKey[3],BumpScene->Palette,18*SEC,PKFF_NOINTERPOLATE);
          FillPKeyEntry(&PKey[3],NULL,BlackPal,20*SEC,PKFF_INTERPOLATE);
          VA3D_AnimSequence(BumpScene->Scene,
                            VA3DAS_PKeyFrames,&PKey,
                            VA3DAS_PaletteHook,&PalHook,
                            VA3DAS_TimerHook,&TimerHook,
                            VA3DAS_RenderHook,&RenderHook,
                            TAG_DONE);

     if(!ShowPicture(KatowiceChunky,KatowicePalette,DisplayID)) CleanUp();
     free(KatowiceChunky);
     free(Bump_ShineLUT);
     FreeScene(GhostScene);
     FreeScene(QuakeScene);
     FreeScene(BabeScene);
     FreeScene(BumpScene);

     if((RolloScene=LoadAndRelocScene("Data/Roller.va3d","Data/Roller.palette")) == NULL) CleanUp();
     if((CreditsScene=LoadAndRelocScene("Data/Credits.va3d","Data/Credits.palette")) == NULL) CleanUp();
     if((DragonScene=LoadAndRelocScene("Data/Dragon.va3d","Data/Dragon.palette")) == NULL) CleanUp();
     if((VA3DLogoScene=LoadAndRelocScene("Data/VA3DLogo.va3d","Data/VA3DLogo.palette")) == NULL) CleanUp();
     if((NoiseChunky = XPK_UnPackFile("Data/Noise.chunky")) == NULL) CleanUp();
     if((NoisePalette = XPK_UnPackFile("Data/Noise.palette")) == NULL) CleanUp();
     if((EndChunky = XPK_UnPackFile("Data/End.chunky")) == NULL) CleanUp();
     if((EndPalette = XPK_UnPackFile("Data/End.palette")) == NULL) CleanUp();
     if((VA3D_ShineLUT = XPK_UnPackFile("Data/VA3DLogo.ShinePalette")) == NULL) CleanUp();

     while(P61_WaitPos2(20,45));
     ShutDownPicture(KatowicePalette);
     free(KatowicePalette);

          FillPKeyEntry(&PKey[0],&PKey[1],BlackPal,0,0);
          FillPKeyEntry(&PKey[1],&PKey[2],RolloScene->Palette,2*SEC,PKFF_INTERPOLATE);
          FillPKeyEntry(&PKey[2],&PKey[3],RolloScene->Palette,26*SEC,PKFF_NOINTERPOLATE);
          FillPKeyEntry(&PKey[3],NULL,BluePal,28*SEC,PKFF_INTERPOLATE);
          VA3D_AnimSequence(RolloScene->Scene,
                            VA3DAS_PKeyFrames,&PKey,
                            VA3DAS_PaletteHook,&PalHook,
                            VA3DAS_TimerHook,&TimerHook,
                            VA3DAS_RenderHook,&RenderHook,
                            TAG_DONE);

	DragonMObject = (MORPH_OBJECT *)FindEntity(DragonScene->Scene->Entities, "dragon.mdl");
	DragonMObject->Sequence = DragonFly;
	DragonMObject->SeqNumber = 14;
	DragonMObject->CurrentSeq = 0;
	DragonMObject->SeqDelay = 90000;

          FillPKeyEntry(&PKey[0],&PKey[1],BluePal,0,0);
          FillPKeyEntry(&PKey[1],&PKey[2],DragonScene->Palette,2*SEC,PKFF_INTERPOLATE);
          FillPKeyEntry(&PKey[2],&PKey[3],DragonScene->Palette,18*SEC,PKFF_NOINTERPOLATE);
          FillPKeyEntry(&PKey[3],NULL,BlackPal,20*SEC,PKFF_INTERPOLATE);
          VA3D_AnimSequence(DragonScene->Scene,
                            VA3DAS_PKeyFrames,&PKey,
                            VA3DAS_PaletteHook,&PalHook,
                            VA3DAS_TimerHook,&TimerHook,
                            VA3DAS_RenderHook,&RenderHook,
                            TAG_DONE);

          FillPKeyEntry(&PKey[0],&PKey[1],BlackPal,0,0);
          FillPKeyEntry(&PKey[1],&PKey[2],CreditsScene->Palette,2*SEC,PKFF_INTERPOLATE);
          FillPKeyEntry(&PKey[2],&PKey[3],CreditsScene->Palette,30*SEC,PKFF_NOINTERPOLATE);
          FillPKeyEntry(&PKey[3],NULL,BlackPal,32*SEC,PKFF_INTERPOLATE);
          VA3D_AnimSequence(CreditsScene->Scene,
                            VA3DAS_PKeyFrames,&PKey,
                            VA3DAS_PaletteHook,&PalHook,
                            VA3DAS_TimerHook,&TimerHook,
                            VA3DAS_RenderHook,&RenderHook,
                            TAG_DONE);

     if(!ShowPicture2(NoiseChunky,NoisePalette,DisplayID)) CleanUp();

		 for(i=0;i<250;i++) WaitTOF();

     ShutDownPicture(NoisePalette);

          FillPKeyEntry(&PKey[0],&PKey[1],BlackPal,0,0);
          FillPKeyEntry(&PKey[1],&PKey[2],VA3DLogoScene->Palette,2*SEC,PKFF_INTERPOLATE);
          FillPKeyEntry(&PKey[3],NULL,VA3DLogoScene->Palette,10*SEC,PKFF_NOINTERPOLATE);
          VA3D_AnimSequence(VA3DLogoScene->Scene,
                            VA3DAS_PKeyFrames,&PKey,
                            VA3DAS_PaletteHook,&PalHook,
                            VA3DAS_TimerHook,&TimerHook,
                            VA3DAS_RenderHook,&RenderHook,
                            TAG_DONE);

		 while(P61_WaitPos2(33,40));

     FadeOutPalette(DView,VA3DLogoScene->Palette->RGB32,0L,0L,0L,2*SEC);

		 while(P61_WaitPos2(34,1));
     if(!ShowPicture2(EndChunky,EndPalette,DisplayID)) CleanUp();
     StopMusic();
     ShutDownPicture(EndPalette);

		 for(i=0;i<100;i++) WaitTOF();

     free(VA3D_ShineLUT);
     free(EndPalette);
     free(EndChunky);
     free(NoisePalette);
     free(NoiseChunky);
     FreeScene(RolloScene);
     FreeScene(CreditsScene);
     FreeScene(DragonScene);
     FreeScene(VA3DLogoScene);

    VA3D_FreePalette(RedPal);
    VA3D_FreePalette(BluePal);
    VA3D_FreePalette(WhitePal);
    VA3D_FreePalette(BlackPal);
    printf("Alles in ordnung!\n");
    CleanUp();
 }
else
 {
    printf("Cannot Init GFX Engine!\n");
    CleanUp();
 }
}

ULONG __saveds __asm RenderFrameHook(REGISTER __a0 struct Hook *hook,
						       REGISTER __a2 APTR object,
 						       REGISTER __a1 APTR message)
{
 SCENE *Scene = (SCENE*)object;
 DVIEW *tmpDView = (DVIEW *)hook->h_Data;

		VA3D_TransformScene(Scene, Scene->Camera, tmpDView->XView);
		VA3D_ClearXView(Scene, tmpDView->XView);
		VA3D_RenderScene(Scene, Scene->Camera, tmpDView->XView, RT_REAL);

     	VA3D_SafeRender(tmpDView);
	     DView->C2P(tmpDView);
     	FrameEvent();
	     VA3D_SwitchView(tmpDView);
          return 0L;
}

ULONG __saveds __asm RenderQuakeFrameHook(REGISTER __a0 struct Hook *hook,
						       REGISTER __a2 APTR object,
 						       REGISTER __a1 APTR message)
{
 SCENE *Scene = (SCENE*)object;
 DVIEW *tmpDView = (DVIEW *)hook->h_Data;
 STATIC Flag = 0;

		if((CurrentTime >= 30*SEC) && (Flag == 0))
		{
		tmpSeqTime = 30*SEC;
		SoldierMObject->Sequence = SoldierStand_Load_Shoot;
		SoldierMObject->SeqNumber = 55;
		SoldierMObject->CurrentSeq = 0;
		SoldierMObject->SeqDelay = 75000;

		DogMObject->Sequence = DogStand_Pain;
		DogMObject->SeqNumber = 55;
		DogMObject->CurrentSeq = 0;
		DogMObject->SeqDelay = 75000;
		Flag = 1;
		}

		VA3D_TransformScene(Scene, Scene->Camera, tmpDView->XView);
		VA3D_ClearXView(Scene, tmpDView->XView);
		VA3D_RenderScene(Scene, Scene->Camera, tmpDView->XView, RT_REAL);

     	VA3D_SafeRender(tmpDView);
	     DView->C2P(tmpDView);
     	FrameEvent();
	     VA3D_SwitchView(tmpDView);
          return 0L;
}

ULONG __saveds __asm PaletteHookFunc(REGISTER __a0 struct Hook *hook,
						       REGISTER __a2 APTR object,
 						       REGISTER __a1 APTR message)
{
 PALETTE *Palette = (PALETTE*)object;
 DVIEW *tmpDView = (DVIEW *)hook->h_Data;

 LoadRGB32(tmpDView->VP,Palette->RGB32);
 return 0L;
}

SCENE_2 *LoadAndRelocScene(STRPTR SceneName,STRPTR PaletteName)
{
 VOID *tmpSceneData;
 VOID *tmpPaletteData;
 SCENE_2 *Scene;
 ULONG Status;

  if((tmpPaletteData = XPK_UnPackFile(PaletteName)) == NULL) return NULL;
    if((tmpSceneData = XPK_UnPackFile(SceneName)) == NULL) return NULL;
      if((Scene = malloc(sizeof(SCENE_2))) == NULL) return NULL;
        if((Scene->Palette = VA3D_AllocPalette(VA3DAP_RGB32,tmpPaletteData,
                                               VA3DAP_CreateHashTable,TRUE,
                                               TAG_DONE)) == NULL) return NULL;

          free(tmpPaletteData);
             if((Scene->Scene = VA3D_LoadScene(
                                   VA3DLS_FileAddress, tmpSceneData,
                                   VA3DLS_LoadMapHook,&FileHook,
	                              VA3DLS_Status, &Status,
                                   VA3DLS_Palette,Scene->Palette,
                                   TAG_DONE)) == NULL) CleanUp();

    	     VA3D_AllocDeepBuffer(Scene->Scene);

          free(tmpSceneData);

 return Scene;
}

VOID FreeScene(SCENE_2 *Scene)
{
   if(Scene)
    {
    if(Scene->Scene) VA3D_FreeScene(Scene->Scene);
     if(Scene->Palette) VA3D_FreePalette(Scene->Palette);
    free(Scene);
    }     
}

VOID CleanUp(VOID)
{
 VA3D_FreeArcSineTable();
 VA3D_FreeRotateTable();
 VA3D_FreePerspectiveTable();
 if(DView) VA3D_CloseView(DView);
 VA3D_CloseGFX();
 XPK_Close();
 exit(0);
}

VOID FillPKeyEntry(PKEY_FRAME *CurrentKey,PKEY_FRAME *NextKey,PALETTE *Palette,ULONG Time,ULONG Flags)
{
     CurrentKey->Next = NextKey;
     CurrentKey->Palette = Palette;
     CurrentKey->Flags = Flags;
     CurrentKey->Time = Time;
}


ENTITY *FindEntity(ENTITY *Entity, STRPTR Name)
{

	while(Entity)
	{
		if(!strcmp(Entity->Name, Name))
			return Entity;

		Entity = Entity->Next;
	}

	return NULL;
}