home *** CD-ROM | disk | FTP | other *** search
/ Learn 3D Graphics Programming on the PC / Learn_3D_Graphics_Programming_on_the_PC_Ferraro.iso / rwwin / knight.c_ / knight.bin
Encoding:
Text File  |  1995-11-14  |  12.9 KB  |  466 lines
  1. /**********************************************************************
  2.  *
  3.  * File :     knight.c
  4.  *
  5.  * Abstract : Handle knight behaviour and animation control
  6.  *
  7.  **********************************************************************
  8.  *
  9.  * This file is a product of Criterion Software Ltd.
  10.  *
  11.  * This file is provided as is with no warranties of any kind and is
  12.  * provided without any obligation on Criterion Software Ltd. or
  13.  * Canon Inc. to assist in its use or modification.
  14.  *
  15.  * Criterion Software Ltd. will not, under any
  16.  * circumstances, be liable for any lost revenue or other damages arising
  17.  * from the use of this file.
  18.  *
  19.  * Copyright (c) 1995 Criterion Software Ltd.
  20.  * All Rights Reserved.
  21.  *
  22.  * RenderWare is a trademark of Canon Inc.
  23.  *
  24.  ************************************************************************/
  25. #define INCLUDE_SHELLAPI_H
  26.  
  27. #include <windows.h>
  28. #include <mmsystem.h>
  29. #include <stdlib.h>
  30. #include <stdio.h>
  31. #include <string.h>
  32. #include <math.h>
  33.  
  34. #include "rwlib.h"
  35. #include "rwwin.h"
  36.  
  37. #include "common.h"
  38.  
  39. #include "animate.h"
  40. #include "knight.h"
  41. #include "knight.rwh"
  42.  
  43. #define CAM_FLY_STEPS 30
  44. int CamFlyStepDelta;
  45. int CamFlyStep;
  46.  
  47. void SetBackdrop(RwCamera *cam)
  48. {
  49.     RwRaster *r;
  50.     RwV3d v;
  51.     RwV3d xz;        
  52.     RwInt32 ox, oy;
  53.     RwInt32 vp_h;
  54.     double theta;
  55.  
  56.    r = RwGetCameraBackdrop(cam);
  57.    if (r)
  58.   {
  59.       RwGetCameraViewport(cam, 
  60.                           (RwInt32 *)NULL, (RwInt32 *)NULL, (RwInt32 *)NULL, &vp_h);
  61.       RwGetCameraLookAt(cam, &v);
  62.  
  63.       xz.x = v.x;
  64.       xz.z = v.z;
  65.       xz.y = CREAL(0.0);
  66.       RwNormalize(&xz);
  67.       if (xz.x > CREAL(1.0))
  68.         xz.x = CREAL(1.0);
  69.       if (xz.x < CREAL(-1.0))
  70.         xz.x = CREAL(-1.0);
  71.               
  72.       theta = acos(REAL2FL(xz.x));
  73.       ox = (int)((double)RwGetRasterWidth(r) * theta/6.2832);
  74.       if (xz.z < 0.0)
  75.         ox = -ox;
  76.  
  77.       oy = -vp_h/2 + (int)((double)RwGetRasterHeight(r)/2.0 * (1.0 - REAL2FL(v.y)));
  78.       if (oy > RwGetRasterHeight(r) - vp_h)
  79.         oy = RwGetRasterHeight(r) - vp_h;
  80.       if (oy < 0)
  81.         oy = 0;
  82.       RwSetCameraBackdropOffset(cam, ox + RwGetRasterWidth(r)/2, oy);
  83.   }              
  84. }
  85.  
  86. void SetCameraState(HWND window, EnCameraState state)
  87. {
  88.     if (state == CAM_MAIN)
  89.     {
  90.         Camera = MainCamera;
  91.         SetBackdrop(MainCamera);
  92.     }
  93.     else if (((state == CAM_FLY1) || (state == CAM_FLY2)) &&
  94.              ((CameraState == CAM_MAIN) || (CameraState == CAM_KNIGHT1) || (CameraState == CAM_KNIGHT2)))
  95.     {
  96.        if (CameraState == CAM_MAIN)
  97.        {
  98.            Camera = FlyCamera;
  99.            CamFlyStepDelta = 1;
  100.            CamFlyStep = 1;
  101.        }
  102.        else
  103.        {
  104.            CamFlyStepDelta = -1;
  105.            CamFlyStep = CAM_FLY_STEPS -1;
  106.        }
  107.    }
  108.    if (CameraState != state)
  109.    {
  110.        if ((state == CAM_KNIGHT1) || (state == CAM_KNIGHT2))
  111.             RwRemoveClumpFromScene((state == CAM_KNIGHT1) ? Knight1 : Knight2);
  112.        if ((CameraState == CAM_KNIGHT1) || (CameraState == CAM_KNIGHT2))
  113.             RwAddClumpToScene(Scene, (CameraState == CAM_KNIGHT1) ? Knight1 : Knight2);
  114.    }
  115.    CameraState = state;
  116.  
  117.    CheckMenuItem(GetMenu(window), ID_MODE_KNIGHT1, (MF_BYCOMMAND|MF_UNCHECKED));
  118.    CheckMenuItem(GetMenu(window), ID_MODE_KNIGHT2, (MF_BYCOMMAND|MF_UNCHECKED));
  119.    CheckMenuItem(GetMenu(window), ID_MODE_OBSERVER, (MF_BYCOMMAND|MF_UNCHECKED));
  120.    switch (CameraState)
  121.    {
  122.         case CAM_MAIN: 
  123.            CheckMenuItem(GetMenu(window), ID_MODE_OBSERVER, (MF_BYCOMMAND|MF_CHECKED));
  124.            break;
  125.         case CAM_KNIGHT1: 
  126.            CheckMenuItem(GetMenu(window), ID_MODE_KNIGHT1, (MF_BYCOMMAND|MF_CHECKED));
  127.            break;
  128.         case CAM_KNIGHT2: 
  129.            CheckMenuItem(GetMenu(window), ID_MODE_KNIGHT2, (MF_BYCOMMAND|MF_CHECKED));
  130.            break;
  131.    }
  132. }
  133.  
  134. void DoFlyCamera(HWND window)
  135. {
  136.    RwClump *clump;
  137.    RwV3d dest_at, dest_up, dest_pos;
  138.    RwV3d src_at, src_up, src_pos;
  139.    RwReal delta;
  140.  
  141.    clump = RwFindTaggedClump((CameraState == CAM_FLY1) ? Knight1 : Knight2, TAG_head);
  142.    RwGetClumpLTM(clump, RwScratchMatrix());
  143.  
  144.    delta = FL2REAL((float)CamFlyStep/(float)(CAM_FLY_STEPS));
  145.  
  146.    RwGetCameraPosition(MainCamera, &src_pos);
  147.    RwGetCameraLookAt(MainCamera, &src_at);
  148.    RwGetCameraLookUp(MainCamera, &src_up);   
  149.                
  150.    dest_pos.x = CREAL(0.0);dest_pos.y = CREAL(0.0); dest_pos.z = CREAL(0.0);
  151.    dest_up.x = CREAL(0.0); dest_up.y = CREAL(0.0); dest_up.z = CREAL(1.0);
  152.    dest_at.x = CREAL(0.0); dest_at.y = CREAL(-1.0); dest_at.z = CREAL(0.0);       
  153.    RwTransformPoint(&dest_pos, RwScratchMatrix());
  154.    RwTransformVector(&dest_up, RwScratchMatrix());
  155.    RwTransformVector(&dest_at, RwScratchMatrix());
  156.  
  157.    dest_pos.x = RAdd(dest_pos.x,
  158.                      RMul((CameraState == CAM_FLY1) ? CREAL(-4.0): CREAL(4.0),
  159.                           RSub(CREAL(1.0), delta)));
  160.  
  161.    RwSetCameraPosition(FlyCamera,
  162.                            RAdd(src_pos.x, RMul(delta, RSub(dest_pos.x,src_pos.x))),
  163.                            RAdd(src_pos.y, RMul(delta, RSub(dest_pos.y,src_pos.y))),
  164.                            RAdd(src_pos.z, RMul(delta, RSub(dest_pos.z,src_pos.z))));
  165.  
  166.    RwPointCamera(FlyCamera, CREAL(0.0), CREAL(0.0), CREAL(0.0));
  167.    RwSetCameraLookUp(FlyCamera, CREAL(0.0), CREAL(1.0), CREAL(0.0));
  168.    CamFlyStep += CamFlyStepDelta;
  169.  
  170.    if ((CamFlyStepDelta > 0) && (CamFlyStep == CAM_FLY_STEPS))
  171.    {
  172.        SetCameraState(window, (CameraState == CAM_FLY1) ? CAM_KNIGHT1 : CAM_KNIGHT2);
  173.    }
  174.    else if (CamFlyStep == 0)
  175.    {
  176.        SetCameraState(window, CAM_MAIN);
  177.    }
  178.    SetBackdrop(FlyCamera);
  179. }
  180.  
  181. void KnightCamera(void)
  182. {
  183.    RwClump *clump;
  184.  
  185.    if ((CameraState == CAM_KNIGHT1) || (CameraState == CAM_KNIGHT2))
  186.    {
  187.        clump = RwFindTaggedClump((CameraState == CAM_KNIGHT1) ? Knight1 : Knight2, TAG_head);
  188.        RwGetClumpLTM(clump, RwScratchMatrix());
  189.        RwTransformCamera(FlyCamera, RwScratchMatrix(), rwREPLACE);
  190.        RwTiltCamera(FlyCamera, CREAL(90.0));
  191.    }
  192.    SetBackdrop(FlyCamera);
  193. }
  194.  
  195. void AnimateCamera(HWND window)
  196. {
  197.     static int Frame = 0;
  198.     static long Duration = 200;
  199.  
  200.     Frame++;
  201.     if (!InterActive)
  202.     {
  203.         RwSetCameraPosition(MainCamera, CREAL(0.0), CREAL(0.0), CREAL(0.0));
  204. #if 0
  205.         RwVCMoveCamera(MainCamera, CREAL(0.0), CREAL(0.0), -CAMERA_DISTANCE);
  206. #endif
  207.         RwPanCamera(MainCamera, CREAL(2.0));
  208.         RwVCMoveCamera(MainCamera, CREAL(0.0), CREAL(0.0), CAMERA_DISTANCE);
  209.         if (CameraState == CAM_MAIN)
  210.             SetBackdrop(MainCamera);
  211.  
  212.         if (!(Frame % Duration))
  213.         {
  214.             switch(CameraState)
  215.             {
  216.                 case CAM_MAIN:
  217.                   SetCameraState(window, (Duration & 0x01) ? CAM_FLY1: CAM_FLY2);
  218.                   break;
  219.                 case CAM_KNIGHT1:
  220.                 case CAM_KNIGHT2:
  221.                   SetCameraState(window, (CameraState == CAM_KNIGHT1) ? CAM_FLY1 : CAM_FLY2);
  222.                   break;
  223.                     
  224.             }
  225.             Duration = RANDOM_INT(100, 500);
  226.         }
  227.     }
  228.        
  229.     switch (CameraState)
  230.     {
  231.         case CAM_MAIN:
  232.            break;
  233.         case CAM_KNIGHT1: 
  234.         case CAM_KNIGHT2:
  235.            KnightCamera();
  236.            break;
  237.            
  238.         case CAM_FLY1:
  239.         case CAM_FLY2:
  240.            DoFlyCamera(window);
  241.            break;
  242.     }
  243. }
  244.  
  245. void RenderKnight(void)
  246. {
  247.   RwClump *clump;
  248.  
  249.   /* this is a cheat to force quick rendering when viewing from a knights eye point */
  250.   if ((CameraState == CAM_KNIGHT1) || (CameraState == CAM_KNIGHT2))
  251.   {
  252.       RwRemoveLightFromScene(Light); /* put in the default scene */
  253.  
  254.       clump = (CameraState == CAM_KNIGHT1) ? Knight1 : Knight2;
  255.  
  256.       RwRenderClump(RwFindTaggedClump(clump, TAG_Object));  
  257.       RwRenderClump(RwFindTaggedClump(clump, TAG_SHIELD));  
  258.       RwRenderClump(RwFindTaggedClump(clump, TAG_lefthand));  
  259.       RwRenderClump(RwFindTaggedClump(clump, TAG_left4arm));  
  260.  
  261.       RwAddLightToScene(Scene, Light); /* put it back in the scene */
  262.   }
  263. }
  264.  
  265. RwClump *RemoveTexture(RwClump *c)
  266. {
  267.    RwForAllPolygonsInClumpPointer(c, (RwPolygon3dFuncPointer)RwSetPolygonTexture, NULL);
  268.    return(c);
  269. } 
  270.  
  271.  
  272. int LoadKnight(HWND window, HINSTANCE inst, RwScene *scene)
  273. {
  274.    char buffer[64];
  275.    int i;        
  276.     
  277.    GetModuleFileName(inst, buffer, sizeof(buffer));
  278.    i = strlen(buffer);
  279.    while(buffer[i] != '\\')
  280.    i--;
  281.  
  282.    Knight1 = LoadClump(window, "knight.rwx");
  283.    if (!Knight1)
  284.        return FALSE;        
  285.    RwAddClumpToScene(scene, Knight1);
  286.    RwRotateMatrix(RwScratchMatrix(), CREAL(0.0), CREAL(1.0), CREAL(0.0), CREAL(90.0), rwREPLACE);
  287.    RwTransformClumpJoint(Knight1, RwScratchMatrix(), rwREPLACE);
  288.    RwTranslateMatrix(RwScratchMatrix(), CREAL(-1.3), CREAL(0.4), CREAL(0.0), rwREPLACE);
  289.    RwTransformClump(Knight1, RwScratchMatrix(), rwREPLACE);
  290.  
  291.    Knight2 = RwDuplicateClump(Knight1);
  292.    if (!Knight2)
  293.        return FALSE;
  294.  
  295.    RwForAllClumpsInHierarchy(Knight2, RemoveTexture);
  296.            
  297.    RwAddClumpToScene(scene, Knight2);
  298.    RwRotateMatrix(RwScratchMatrix(), CREAL(0.0), CREAL(1.0), CREAL(0.0), CREAL(-90.0), rwREPLACE);
  299.    RwTransformClumpJoint(Knight2, RwScratchMatrix(), rwREPLACE);
  300.    RwTranslateMatrix(RwScratchMatrix(), CREAL(1.3), CREAL(0.4), CREAL(0.0), rwREPLACE);
  301.    RwTransformClump(Knight2, RwScratchMatrix(), rwREPLACE);
  302.  
  303.    buffer[i+1] = 0;
  304.    strcat(buffer, "KNIGHT.RWV");
  305.  
  306.     RwForAllClumpsInHierarchyLong(Knight1, (RwClumpFuncLong)RwSetClumpHints, 0L);
  307.     RwForAllClumpsInHierarchyLong(Knight2, (RwClumpFuncLong)RwSetClumpHints, 0L);
  308.  
  309.    LoadAnimation(Knight1, buffer);
  310.    LoadAnimation(Knight2, buffer);
  311.    
  312.    DefineAnimation(Knight1, "BOB1", 0, 10, 5);
  313.    DefineAnimation(Knight1, "SLASH", 10, 35, 12);
  314.    DefineAnimation(Knight1, "BOB2", 35, 45, 40);
  315.    DefineAnimation(Knight1, "PARRY", 45, 60, 48);
  316.    DefineAnimation(Knight1, "BOB3", 60, 70, 65);
  317.    DefineAnimation(Knight1, "HIT", 70, 85, 85);
  318.  
  319.    DefineAnimation(Knight2, "BOB1", 0, 10, 5);
  320.    DefineAnimation(Knight2, "SLASH", 10, 35, 12);
  321.    DefineAnimation(Knight2, "BOB2", 35, 45, 40);
  322.    DefineAnimation(Knight2, "PARRY", 45, 60, 50);
  323.    DefineAnimation(Knight2, "BOB3", 60, 70, 65);
  324.    DefineAnimation(Knight2, "HIT", 70, 85, 85);
  325.  
  326.    return TRUE;
  327. }
  328.  
  329. char *RandomKnight(RwClump *clump)
  330. {
  331.      long i;
  332.  
  333.      /* if the other knight isn`t doing anything then don`t attack */        
  334.      if (((clump == Knight1) && (GetAnimationState(Knight2) != A_ON)) ||
  335.          ((clump == Knight2) && (GetAnimationState(Knight1) != A_ON)))
  336.          return "BOB1";        
  337.      
  338.      i = RANDOM_INT(0, 1);
  339.      switch(i)
  340.      {
  341.           case 0:
  342.              return "SLASH";
  343.           default:
  344.              return "BOB1";
  345.      } 
  346. }
  347.  
  348. int CheckKnightAnimation(RwClump *clump)
  349. {
  350.     TyAnimationData *ad;
  351.  
  352.     ad = RwGetClumpData(clump);
  353.     if (ad)
  354.     {
  355.         if (ad->current_animation)
  356.         {
  357.             return (ad->current_animation->end - ad->current_frame);
  358.         }
  359.     }
  360.     return (0);
  361. }
  362.  
  363. #ifdef WITH_SOUND
  364. static char *Sound = NULL;
  365. static int SoundDelay = 0;
  366.  
  367. void DelaySound(char *wav, int delay)
  368. {  
  369.     char buffer[128];
  370.     if (!Sound)
  371.     {                
  372.         sprintf (buffer, "open %s", wav);
  373.         mciSendString(buffer, NULL, 0, 0);
  374.         Sound = wav;
  375.         SoundDelay = delay;
  376.     }
  377.         
  378. }
  379.  
  380. void PlaySound(void)
  381. {
  382.     char buffer[128];
  383.     if (Sound)
  384.     {
  385.         SoundDelay--;
  386.         if (!SoundDelay)
  387.         {            
  388.             sprintf (buffer, "play %s from 0", Sound);
  389.             mciSendString(buffer, NULL, 0, 0);
  390.             Sound = NULL;
  391.         }
  392.     }
  393. }
  394. #endif
  395.  
  396. void ReactKnight(RwClump *clump, TyAnimation *a)
  397. {
  398.    char *response;
  399.    long i;
  400.    
  401.    if (!strcmp(a->name, "HIT"))
  402.    {
  403.        SetAnimationState(clump, A_DISSOLVE);
  404.        return;   
  405.    }
  406.    else if (!strcmp(a->name, "SLASH"))
  407.    {
  408.        i = RANDOM_INT(0, 10);
  409.        if (i == 7) 
  410.        {
  411.            response = "HIT";
  412. #ifdef WITH_SOUND
  413.             DelaySound("scream.wav", 12);
  414. #endif
  415.         }
  416.        else
  417.        {
  418.           response = "PARRY";
  419. #ifdef WITH_SOUND
  420.           DelaySound("thunk.wav", 12);
  421. #endif
  422.        }
  423.    }
  424.    else
  425.    {
  426.       i = RANDOM_INT(0, 5);
  427.       switch (i)
  428.       {
  429.           case 0:
  430.           case 1:
  431.               response = "SLASH";
  432.               break;
  433.           case 2:
  434.               response = "BOB1";
  435.               break;
  436.           case 3:
  437.               response = "BOB2";
  438.               break;
  439.           default:
  440.               response = "BOB3";
  441.               break;
  442.       }
  443.    }
  444.    if (clump == Knight1)
  445.    {
  446.        if (CheckKnightAnimation(Knight2) < 15)
  447.            StartAnimation(Knight2, response);
  448.    }
  449.    else
  450.    {
  451.        if (CheckKnightAnimation(Knight1) < 15)
  452.            StartAnimation(Knight1, response);
  453.    }
  454. }
  455.  
  456. void AnimateKnight(int knight, char *name)
  457. {
  458.    SetAnimationState(Knight1, A_ON);
  459.    SetAnimationState(Knight2, A_ON);
  460.    switch (knight)
  461.    {
  462.        case 1: StartAnimation(Knight1, name); break;
  463.        case 2: StartAnimation(Knight2, name); break;
  464.    }
  465. }
  466.