home *** CD-ROM | disk | FTP | other *** search
/ Learn 3D Graphics Programming on the PC / Learn_3D_Graphics_Programming_on_the_PC_Ferraro.iso / rwdos / dknight.c < prev    next >
C/C++ Source or Header  |  1995-02-15  |  11KB  |  378 lines
  1. #define INCLUDE_SHELLAPI_H
  2.  
  3. #include <i86.h>
  4. #include <stdlib.h>
  5. #include <stdio.h>
  6. #include <math.h>    /* Required for floating point */
  7. #include <string.h>
  8.  
  9. #include "rwlib.h"
  10. #include "rwdos.h"
  11.  
  12. #include "danimate.h"
  13. #include "dknight.h"
  14. #include "knight.rwh"
  15.  
  16. #define CAM_FLY_STEPS 30
  17. int CamFlyStepDelta;
  18. int CamFlyStep;
  19.  
  20. void SetBackdrop(RwCamera *cam)
  21. {
  22.     RwRaster *r;
  23.     RwV3d v;
  24.     RwV3d xz;
  25.     int ox, oy;
  26.     RwInt32 vp_h;
  27.     RwInt32 dummy;
  28.     float theta;
  29.  
  30.    r = RwGetCameraBackdrop(cam);
  31.    if (r)
  32.   {
  33.       RwGetCameraViewport(cam, &dummy, &dummy, &dummy, &vp_h);
  34.       RwGetCameraLookAt(cam, &v);
  35.  
  36.       xz.x = v.x;
  37.       xz.z = v.z;
  38.       xz.y = CREAL(0.0);
  39.       RwNormalize(&xz);
  40.       if (xz.x > CREAL(1.0))
  41.         xz.x = CREAL(1.0);
  42.       if (xz.x < CREAL(-1.0))
  43.         xz.x = CREAL(-1.0);
  44.  
  45.       theta = acos(REAL2FL(xz.x));
  46.       ox = (int)((float)RwGetRasterWidth(r) * theta/6.2832);
  47.       if (xz.z < 0.0)
  48.         ox = -ox;
  49.  
  50.       oy = -vp_h/2 + (int)((float)RwGetRasterHeight(r)/2.0 * (1.0 - REAL2FL(v.y)));
  51.       if (oy > RwGetRasterHeight(r) - vp_h)
  52.         oy = RwGetRasterHeight(r) - vp_h;
  53.       if (oy < 0)
  54.         oy = 0;
  55.       RwSetCameraBackdropOffset(cam, ox + RwGetRasterWidth(r)/2, oy);
  56.   }
  57. }
  58.  
  59. void SetCameraState(EnCameraState state)
  60. {
  61.  
  62.     if (state == CAM_MAIN)
  63.     {
  64.         Camera = MainCamera;
  65.         SetBackdrop(MainCamera);
  66.     }
  67.     else if (((state == CAM_FLY1) || (state == CAM_FLY2)) &&
  68.              ((CameraState == CAM_MAIN) || (CameraState == CAM_KNIGHT1) || (CameraState == CAM_KNIGHT2)))
  69.     {
  70.        if (CameraState == CAM_MAIN)
  71.        {
  72.            Camera = FlyCamera;
  73.            CamFlyStepDelta = 1;
  74.            CamFlyStep = 1;
  75.        }
  76.        else
  77.        {
  78.            CamFlyStepDelta = -1;
  79.            CamFlyStep = CAM_FLY_STEPS -1;
  80.        }
  81.    }
  82.    if (CameraState != state)
  83.    {
  84.        if ((state == CAM_KNIGHT1) || (state == CAM_KNIGHT2))
  85.             RwRemoveClumpFromScene((state == CAM_KNIGHT1) ? Knight1 : Knight2);
  86.        if ((CameraState == CAM_KNIGHT1) || (CameraState == CAM_KNIGHT2))
  87.             RwAddClumpToScene(Scene, (CameraState == CAM_KNIGHT1) ? Knight1 : Knight2);
  88.    }
  89.    CameraState = state;
  90. /*
  91.    CheckMenuItem(MainMenu, M_KNIGHT1, (MF_BYCOMMAND|MF_UNCHECKED));
  92.    CheckMenuItem(MainMenu, M_KNIGHT2, (MF_BYCOMMAND|MF_UNCHECKED));
  93.    CheckMenuItem(MainMenu, M_OBSERVER, (MF_BYCOMMAND|MF_UNCHECKED));
  94.    switch (CameraState)
  95.    {
  96.         case CAM_MAIN:
  97.            CheckMenuItem(MainMenu, M_OBSERVER, (MF_BYCOMMAND|MF_CHECKED));
  98.            break;
  99.         case CAM_KNIGHT1:
  100.            CheckMenuItem(MainMenu, M_KNIGHT1, (MF_BYCOMMAND|MF_CHECKED));
  101.            break;
  102.         case CAM_KNIGHT2:
  103.            CheckMenuItem(MainMenu, M_KNIGHT2, (MF_BYCOMMAND|MF_CHECKED));
  104.            break;
  105.    }
  106.  
  107.  */
  108. }
  109.  
  110. void DoFlyCamera(void)
  111. {
  112.    RwClump *clump;
  113.    RwV3d dest_at, dest_up, dest_pos;
  114.    RwV3d src_at, src_up, src_pos;
  115.    RwReal delta;
  116.  
  117.    clump = RwFindTaggedClump((CameraState == CAM_FLY1) ? Knight1 : Knight2, TAG_head);
  118.    RwGetClumpLTM(clump, RwScratchMatrix());
  119.  
  120.    delta = FL2REAL((float)CamFlyStep/(float)(CAM_FLY_STEPS));
  121.  
  122.    RwGetCameraPosition(MainCamera, &src_pos);
  123.    RwGetCameraLookAt(MainCamera, &src_at);
  124.    RwGetCameraLookUp(MainCamera, &src_up);
  125.  
  126.    dest_pos.x = CREAL(0.0);dest_pos.y = CREAL(0.0); dest_pos.z = CREAL(0.0);
  127.    dest_up.x = CREAL(0.0); dest_up.y = CREAL(0.0); dest_up.z = CREAL(1.0);
  128.    dest_at.x = CREAL(0.0); dest_at.y = CREAL(-1.0); dest_at.z = CREAL(0.0);
  129.    RwTransformPoint(&dest_pos, RwScratchMatrix());
  130.    RwTransformVector(&dest_up, RwScratchMatrix());
  131.    RwTransformVector(&dest_at, RwScratchMatrix());
  132.  
  133.    dest_pos.x = RAdd(dest_pos.x,
  134.                      RMul((CameraState == CAM_FLY1) ? CREAL(4.0): CREAL(-4.0),
  135.                           RSub(CREAL(1.0), delta)));
  136.  
  137.    RwSetCameraPosition(FlyCamera,
  138.                            RAdd(src_pos.x, RMul(delta, RSub(dest_pos.x,src_pos.x))),
  139.                            RAdd(src_pos.y, RMul(delta, RSub(dest_pos.y,src_pos.y))),
  140.                            RAdd(src_pos.z, RMul(delta, RSub(dest_pos.z,src_pos.z))));
  141.  
  142.    RwPointCamera(FlyCamera, CREAL(0.0), CREAL(0.0), CREAL(0.0));
  143.    RwSetCameraLookUp(FlyCamera, CREAL(0.0), CREAL(1.0), CREAL(0.0));
  144.    CamFlyStep += CamFlyStepDelta;
  145.  
  146.    if ((CamFlyStepDelta > 0) && (CamFlyStep == CAM_FLY_STEPS))
  147.    {
  148.        SetCameraState((CameraState == CAM_FLY1) ? CAM_KNIGHT1 : CAM_KNIGHT2);
  149.    }
  150.    else if (CamFlyStep == 0)
  151.    {
  152.        SetCameraState(CAM_MAIN);
  153.    }
  154.    SetBackdrop(FlyCamera);
  155. }
  156.  
  157. void KnightCamera(void)
  158. {
  159.    RwClump *clump;
  160.  
  161.    if ((CameraState == CAM_KNIGHT1) || (CameraState == CAM_KNIGHT2))
  162.    {
  163.        RwSetCameraPosition(FlyCamera, CREAL(0.0), CREAL(0.0), CREAL(0.0));
  164.        RwSetCameraLookUp(FlyCamera, CREAL(0.0), CREAL(0.0), CREAL(1.0));
  165.        RwSetCameraLookAt(FlyCamera, CREAL(0.0), CREAL(-1.0), CREAL(0.0));
  166.  
  167.        clump = RwFindTaggedClump((CameraState == CAM_KNIGHT1) ? Knight1 : Knight2, TAG_head);
  168.        RwGetClumpLTM(clump, RwScratchMatrix());
  169.        RwTransformCamera(FlyCamera, RwScratchMatrix(),rwPOSTCONCAT);
  170.    }
  171.    SetBackdrop(FlyCamera);
  172. }
  173.  
  174. void AnimateCamera(void)
  175. {
  176.     static int Frame = 0;
  177.     static int Duration = 200;
  178.  
  179.     Frame++;
  180.     if (!InterActive)
  181.     {
  182.         RwVCMoveCamera(MainCamera, CREAL(0.0), CREAL(0.0), -CAMERA_DISTANCE);
  183.         RwPanCamera(MainCamera, CREAL(2.0));
  184.         RwVCMoveCamera(MainCamera, CREAL(0.0), CREAL(0.0), CAMERA_DISTANCE);
  185.         if (CameraState == CAM_MAIN)
  186.             SetBackdrop(MainCamera);
  187.  
  188.         if (!(Frame % Duration))
  189.         {
  190.             switch(CameraState)
  191.             {
  192.                 case CAM_MAIN:
  193.                   SetCameraState((Duration & 0x01) ? CAM_FLY1: CAM_FLY2);
  194.                   break;
  195.                 case CAM_KNIGHT1:
  196.                 case CAM_KNIGHT2:
  197.                   SetCameraState((CameraState == CAM_KNIGHT1) ? CAM_FLY1 : CAM_FLY2);
  198.                   break;
  199.  
  200.             }
  201.             Duration = GetRandInt(100, 500);
  202.         }
  203.     }
  204.  
  205.     switch (CameraState)
  206.     {
  207.         case CAM_MAIN:
  208.            break;
  209.         case CAM_KNIGHT1:
  210.         case CAM_KNIGHT2:
  211.            KnightCamera();
  212.            break;
  213.  
  214.         case CAM_FLY1:
  215.         case CAM_FLY2:
  216.            DoFlyCamera();
  217.            break;
  218.     }
  219. }
  220.  
  221. void RenderKnight(void)
  222. {
  223.   RwClump *clump;
  224.  
  225.   /* this is a cheat to force quick rendering when viewing from a knights eye point */
  226.   if ((CameraState == CAM_KNIGHT1) || (CameraState == CAM_KNIGHT2))
  227.   {
  228.       RwRemoveLightFromScene(Light); /* put in the default scene */
  229.  
  230.       clump = (CameraState == CAM_KNIGHT1) ? Knight1 : Knight2;
  231.  
  232.       RwRenderClump(RwFindTaggedClump(clump, TAG_Object));
  233.       RwRenderClump(RwFindTaggedClump(clump, TAG_SHIELD));
  234.       RwRenderClump(RwFindTaggedClump(clump, TAG_lefthand));
  235.       RwRenderClump(RwFindTaggedClump(clump, TAG_left4arm));
  236.  
  237.       RwAddLightToScene(Scene, Light); /* put it back in the scene */
  238.   }
  239. }
  240.  
  241. int LoadKnight(RwScene *scene)
  242. {
  243.    Knight1 = LoadClump( "knight1.rwx");
  244.    if (!Knight1)
  245.        return FALSE;
  246.    RwAddClumpToScene(scene, Knight1);
  247.    RwRotateMatrix(RwScratchMatrix(), CREAL(0.0), CREAL(1.0), CREAL(0.0), CREAL(-90.0), rwREPLACE);
  248.    RwTransformClumpJoint(Knight1, RwScratchMatrix(), rwREPLACE);
  249.    RwTranslateMatrix(RwScratchMatrix(), CREAL(1.3), CREAL(0.4), CREAL(0.0), rwREPLACE);
  250.    RwTransformClump(Knight1, RwScratchMatrix(), rwREPLACE);
  251.  
  252.    Knight2 = LoadClump("knight2.rwx");
  253.    if (!Knight2)
  254.        return FALSE;
  255.    RwAddClumpToScene(scene, Knight2);
  256.    RwRotateMatrix(RwScratchMatrix(), CREAL(0.0), CREAL(1.0), CREAL(0.0), CREAL(90.0), rwREPLACE);
  257.    RwTransformClumpJoint(Knight2, RwScratchMatrix(), rwREPLACE);
  258.    RwTranslateMatrix(RwScratchMatrix(), CREAL(-1.3), CREAL(0.4), CREAL(0.0), rwREPLACE);
  259.    RwTransformClump(Knight2, RwScratchMatrix(), rwREPLACE);
  260.  
  261.    RwForAllClumpsInHierarchyLong(Knight1, RwSetClumpHints, 0L);
  262.    RwForAllClumpsInHierarchyLong(Knight2, RwSetClumpHints, 0L);
  263.  
  264.    LoadAnimation(Knight1, ".\\knight.rwv");
  265.    LoadAnimation(Knight2, ".\\knight.rwv");
  266.  
  267.    DefineAnimation(Knight1, "BOB1", 0, 10, 5);
  268.    DefineAnimation(Knight1, "SLASH", 10, 35, 12);
  269.    DefineAnimation(Knight1, "BOB2", 35, 45, 40);
  270.    DefineAnimation(Knight1, "PARRY", 45, 60, 48);
  271.    DefineAnimation(Knight1, "BOB3", 60, 70, 65);
  272.    DefineAnimation(Knight1, "HIT", 70, 85, 85);
  273.  
  274.    DefineAnimation(Knight2, "BOB1", 0, 10, 5);
  275.    DefineAnimation(Knight2, "SLASH", 10, 35, 14);
  276.    DefineAnimation(Knight2, "BOB2", 35, 45, 40);
  277.    DefineAnimation(Knight2, "PARRY", 45, 60, 50);
  278.    DefineAnimation(Knight2, "BOB3", 60, 70, 65);
  279.    DefineAnimation(Knight2, "HIT", 70, 85, 85);
  280.  
  281.    return TRUE;
  282. }
  283.  
  284. char *RandomKnight(RwClump *clump)
  285. {
  286.      int i;
  287.  
  288.      /* if the other knight isn`t doing anything then don`t attack */
  289.      if (((clump == Knight1) && (GetAnimationState(Knight2) != A_ON)) ||
  290.          ((clump == Knight2) && (GetAnimationState(Knight1) != A_ON)))
  291.          return "BOB1";
  292.  
  293.      i = GetRandInt(0, 1);
  294.      switch(i)
  295.      {
  296.           case 0:
  297.              return "SLASH";
  298.           default:
  299.              return "BOB1";
  300.      }
  301. }
  302.  
  303. int CheckKnightAnimation(RwClump *clump)
  304. {
  305.     TyAnimationData *ad;
  306.  
  307.     ad = RwGetClumpData(clump);
  308.     if (ad)
  309.     {
  310.         if (ad->current_animation)
  311.         {
  312.             return (ad->current_animation->end - ad->current_frame);
  313.         }
  314.     }
  315.     return (0);
  316. }
  317.  
  318. void ReactKnight(RwClump *clump, TyAnimation *a)
  319. {
  320.    char *response;
  321.    int i;
  322.  
  323.    if (!strcmp(a->name, "HIT"))
  324.    {
  325.        SetAnimationState(clump, A_DISSOLVE);
  326.        return;
  327.    }
  328.    else if (!strcmp(a->name, "SLASH"))
  329.    {
  330.        i = GetRandInt(0, 10);
  331.        if (i == 7)
  332.            response = "HIT";
  333.        else
  334.            response = "PARRY";
  335.    }
  336.    else
  337.    {
  338.       i = GetRandInt(0, 5);
  339.       switch (i)
  340.       {
  341.           case 0:
  342.           case 1:
  343.               response = "SLASH";
  344.               break;
  345.           case 2:
  346.               response = "BOB1";
  347.               break;
  348.           case 3:
  349.               response = "BOB2";
  350.               break;
  351.           default:
  352.               response = "BOB3";
  353.               break;
  354.       }
  355.    }
  356.    if (clump == Knight1)
  357.    {
  358.        if (CheckKnightAnimation(Knight2) < 15)
  359.            StartAnimation(Knight2, response);
  360.    }
  361.    else
  362.    {
  363.        if (CheckKnightAnimation(Knight1) < 15)
  364.            StartAnimation(Knight1, response);
  365.    }
  366. }
  367.  
  368. void AnimateKnight(int knight, char *name)
  369. {
  370.    SetAnimationState(Knight1, A_ON);
  371.    SetAnimationState(Knight2, A_ON);
  372.    switch (knight)
  373.    {
  374.        case 1: StartAnimation(Knight1, name); break;
  375.        case 2: StartAnimation(Knight2, name); break;
  376.    }
  377. }
  378.