SDL-1.3/android-project/jni/SDL/Xcode/TemplatesForXcodeSnowLeopard/SDL OpenGL Application/atlantis/swim.c

   1 /**
   2  * (c) Copyright 1993, 1994, Silicon Graphics, Inc.
   3  * ALL RIGHTS RESERVED
   4  * Permission to use, copy, modify, and distribute this software for
   5  * any purpose and without fee is hereby granted, provided that the above
   6  * copyright notice appear in all copies and that both the copyright notice
   7  * and this permission notice appear in supporting documentation, and that
   8  * the name of Silicon Graphics, Inc. not be used in advertising
   9  * or publicity pertaining to distribution of the software without specific,
  10  * written prior permission.
  11  *
  12  * THE MATERIAL EMBODIED ON THIS SOFTWARE IS PROVIDED TO YOU "AS-IS"
  13  * AND WITHOUT WARRANTY OF ANY KIND, EXPRESS, IMPLIED OR OTHERWISE,
  14  * INCLUDING WITHOUT LIMITATION, ANY WARRANTY OF MERCHANTABILITY OR
  15  * FITNESS FOR A PARTICULAR PURPOSE.  IN NO EVENT SHALL SILICON
  16  * GRAPHICS, INC.  BE LIABLE TO YOU OR ANYONE ELSE FOR ANY DIRECT,
  17  * SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY
  18  * KIND, OR ANY DAMAGES WHATSOEVER, INCLUDING WITHOUT LIMITATION,
  19  * LOSS OF PROFIT, LOSS OF USE, SAVINGS OR REVENUE, OR THE CLAIMS OF
  20  * THIRD PARTIES, WHETHER OR NOT SILICON GRAPHICS, INC.  HAS BEEN
  21  * ADVISED OF THE POSSIBILITY OF SUCH LOSS, HOWEVER CAUSED AND ON
  22  * ANY THEORY OF LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE
  23  * POSSESSION, USE OR PERFORMANCE OF THIS SOFTWARE.
  24  *
  25  * US Government Users Restricted Rights
  26  * Use, duplication, or disclosure by the Government is subject to
  27  * restrictions set forth in FAR 52.227.19(c)(2) or subparagraph
  28  * (c)(1)(ii) of the Rights in Technical Data and Computer Software
  29  * clause at DFARS 252.227-7013 and/or in similar or successor
  30  * clauses in the FAR or the DOD or NASA FAR Supplement.
  31  * Unpublished-- rights reserved under the copyright laws of the
  32  * United States.  Contractor/manufacturer is Silicon Graphics,
  33  * Inc., 2011 N.  Shoreline Blvd., Mountain View, CA 94039-7311.
  34  *
  35  * OpenGL(TM) is a trademark of Silicon Graphics, Inc.
  36  */
  37 #include <math.h>
  38 #include <stdlib.h>  /* For rand(). */
  39 #include <GLUT/glut.h>
  40 #include "atlantis.h"
  41
  42 void
  43 FishTransform(fishRec * fish)
  44 {
  45
  46     glTranslatef(fish->y, fish->z, -fish->x);
  47     glRotatef(-fish->psi, 0.0, 1.0, 0.0);
  48     glRotatef(fish->theta, 1.0, 0.0, 0.0);
  49     glRotatef(-fish->phi, 0.0, 0.0, 1.0);
  50 }
  51
  52 void
  53 WhalePilot(fishRec * fish)
  54 {
  55
  56     fish->phi = -20.0;
  57     fish->theta = 0.0;
  58     fish->psi -= 0.5;
  59
  60     fish->x += WHALESPEED * fish->v * cos(fish->psi / RAD) * cos(fish->theta / RAD);
  61     fish->y += WHALESPEED * fish->v * sin(fish->psi / RAD) * cos(fish->theta / RAD);
  62     fish->z += WHALESPEED * fish->v * sin(fish->theta / RAD);
  63 }
  64
  65 void
  66 SharkPilot(fishRec * fish)
  67 {
  68     static int sign = 1;
  69     float X, Y, Z, tpsi, ttheta, thetal;
  70
  71     fish->xt = 60000.0;
  72     fish->yt = 0.0;
  73     fish->zt = 0.0;
  74
  75     X = fish->xt - fish->x;
  76     Y = fish->yt - fish->y;
  77     Z = fish->zt - fish->z;
  78
  79     thetal = fish->theta;
  80
  81     ttheta = RAD * atan(Z / (sqrt(X * X + Y * Y)));
  82
  83     if (ttheta > fish->theta + 0.25) {
  84         fish->theta += 0.5;
  85     } else if (ttheta < fish->theta - 0.25) {
  86         fish->theta -= 0.5;
  87     }
  88     if (fish->theta > 90.0) {
  89         fish->theta = 90.0;
  90     }
  91     if (fish->theta < -90.0) {
  92         fish->theta = -90.0;
  93     }
  94     fish->dtheta = fish->theta - thetal;
  95
  96     tpsi = RAD * atan2(Y, X);
  97
  98     fish->attack = 0;
  99
 100     if (fabs(tpsi - fish->psi) < 10.0) {
 101         fish->attack = 1;
 102     } else if (fabs(tpsi - fish->psi) < 45.0) {
 103         if (fish->psi > tpsi) {
 104             fish->psi -= 0.5;
 105             if (fish->psi < -180.0) {
 106                 fish->psi += 360.0;
 107             }
 108         } else if (fish->psi < tpsi) {
 109             fish->psi += 0.5;
 110             if (fish->psi > 180.0) {
 111                 fish->psi -= 360.0;
 112             }
 113         }
 114     } else {
 115         if (rand() % 100 > 98) {
 116             sign = 1 - sign;
 117         }
 118         fish->psi += sign;
 119         if (fish->psi > 180.0) {
 120             fish->psi -= 360.0;
 121         }
 122         if (fish->psi < -180.0) {
 123             fish->psi += 360.0;
 124         }
 125     }
 126
 127     if (fish->attack) {
 128         if (fish->v < 1.1) {
 129             fish->spurt = 1;
 130         }
 131         if (fish->spurt) {
 132             fish->v += 0.2;
 133         }
 134         if (fish->v > 5.0) {
 135             fish->spurt = 0;
 136         }
 137         if ((fish->v > 1.0) && (!fish->spurt)) {
 138             fish->v -= 0.2;
 139         }
 140     } else {
 141         if (!(rand() % 400) && (!fish->spurt)) {
 142             fish->spurt = 1;
 143         }
 144         if (fish->spurt) {
 145             fish->v += 0.05;
 146         }
 147         if (fish->v > 3.0) {
 148             fish->spurt = 0;
 149         }
 150         if ((fish->v > 1.0) && (!fish->spurt)) {
 151             fish->v -= 0.05;
 152         }
 153     }
 154
 155     fish->x += SHARKSPEED * fish->v * cos(fish->psi / RAD) * cos(fish->theta / RAD);
 156     fish->y += SHARKSPEED * fish->v * sin(fish->psi / RAD) * cos(fish->theta / RAD);
 157     fish->z += SHARKSPEED * fish->v * sin(fish->theta / RAD);
 158 }
 159
 160 void
 161 SharkMiss(int i)
 162 {
 163     int j;
 164     float avoid, thetal;
 165     float X, Y, Z, R;
 166
 167     for (j = 0; j < NUM_SHARKS; j++) {
 168         if (j != i) {
 169             X = sharks[j].x - sharks[i].x;
 170             Y = sharks[j].y - sharks[i].y;
 171             Z = sharks[j].z - sharks[i].z;
 172
 173             R = sqrt(X * X + Y * Y + Z * Z);
 174
 175             avoid = 1.0;
 176             thetal = sharks[i].theta;
 177
 178             if (R < SHARKSIZE) {
 179                 if (Z > 0.0) {
 180                     sharks[i].theta -= avoid;
 181                 } else {
 182                     sharks[i].theta += avoid;
 183                 }
 184             }
 185             sharks[i].dtheta += (sharks[i].theta - thetal);
 186         }
 187     }
 188 }