caosVM_vectors.cpp

   1 /*
   2  *  caosVM_variables.cpp
   3  *  openc2e
   4  *
   5  *  Created by Bryan Donlan on Sun Jul 23 2006
   6  *  Copyright (c) 2006 Bryan Donlan. All rights reserved.
   7  *
   8  *  This library is free software; you can redistribute it and/or
   9  *  modify it under the terms of the GNU Lesser General Public
  10  *  License as published by the Free Software Foundation; either
  11  *  version 2 of the License, or (at your option) any later version.
  12  *
  13  *  This library is distributed in the hope that it will be useful,
  14  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16  *  Lesser General Public License for more details.
  17  *
  18  */
  19
  20 #include "caosVM.h"
  21 #include <cmath>
  22 #include "caosVar.h"
  23 #include "physics.h"
  24
  25 #define PI (atanf(1)*4)
  26
  27 /**
  28  * VEC: MAKE (vector) x (float) y (float)
  29  * %status maybe
  30  *
  31  * Creates and returns a vector with the given components.
  32  *
  33  * Openc2e-only command
  34  */
  35
  36         void caosVM::v_VEC_MAKE() {
  37                 VM_PARAM_FLOAT(y)
  38                 VM_PARAM_FLOAT(x)
  39
  40                 result.setVector(Vector<float>(x, y));
  41         }
  42
  43 /**
  44  * VEC: GETC (command) vec (vector) x (variable) y (variable)
  45  * %status maybe
  46  *
  47  * Extracts the components of vector vec and places them in x and y.
  48  *
  49  * Openc2e-only command
  50  */
  51
  52         void caosVM::c_VEC_GETC() {
  53                 VM_PARAM_VARIABLE(y)
  54                 VM_PARAM_VARIABLE(x)
  55                 VM_PARAM_VECTOR(vec)
  56
  57                 x->setFloat(vec.x);
  58                 y->setFloat(vec.y);
  59         }
  60
  61 /**
  62  * VEC: ANGL (float) vec (vector)
  63  * %status maybe
  64  *
  65  * Find and return the angle from the X-axis of the given vector.
  66  * This is computed using atan(y/x) if X is nonzero, and a hard-coded
  67  * return if X is nonzero. If the input vector is the null vector (0,0),
  68  * zero will be returned.
  69  *
  70  * The returned angle is in degrees, and in the range -180 to 180 degrees.
  71  *
  72  * Openc2e-only command.
  73  */
  74
  75 void caosVM::v_VEC_ANGL() {
  76         float ret = 0;
  77         VM_PARAM_VECTOR(vec)
  78
  79         if (vec.x != 0) {
  80                 ret = atanf(fabsf(vec.y/vec.x))*180/PI;
  81                 if (vec.x < 0)
  82                         ret = 180 - ret;
  83                 if (vec.y < 0)
  84                         ret = -ret;
  85         }
  86         else if (vec.y > 0)
  87                 ret = 90;
  88         else if (vec.y < 0)
  89                 ret = -90;
  90         else if (vec.y == 0)
  91                 ret = 0;
  92         if (ret == -180)
  93                 ret = 180; // hacky -_-;;
  94
  95         result.setFloat(ret);
  96 }
  97
  98 /**
  99  * VEC: SUBV (command) vec1 (variable) vec2 (vector)
 100  * %status maybe
 101  *
 102  * Subtracts vec2 from vec1 and stores the result in vec1.
 103  *
 104  * Openc2e-only command.
 105  */
 106
 107         void caosVM::c_VEC_SUBV() {
 108                 VM_PARAM_VECTOR(vec2)
 109                 VM_PARAM_VARIABLE(vec1)
 110
 111                 if (!vec1->hasVector())
 112                         throw badParamException();
 113
 114                 vec1->setVector(vec1->getVector() - vec2);
 115         }
 116
 117 /**
 118  * VEC: ADDV (command) vec1 (variable) vec2 (vector)
 119  * %status maybe
 120  *
 121  * Adds vec1 to vec2 and stores the result in vec1.
 122  *
 123  * Openc2e-only command.
 124  */
 125
 126         void caosVM::c_VEC_ADDV() {
 127                 VM_PARAM_VECTOR(vec2)
 128                 VM_PARAM_VARIABLE(vec1)
 129
 130                 if (!vec1->hasVector())
 131                         throw badParamException();
 132
 133                 vec1->setVector(vec1->getVector() + vec2);
 134         }
 135
 136 /**
 137  * VEC: MULV (command) vec (variable) mag (decimal)
 138  * %status maybe
 139  *
 140  * Multiplies the magnitude of the vector vec by mag, and stores the result
 141  * in vec.
 142  *
 143  * Openc2e-only command
 144  */
 145
 146         void caosVM::c_VEC_MULV() {
 147                 VM_PARAM_FLOAT(mag)
 148                 VM_PARAM_VARIABLE(vec)
 149
 150                 if (!vec->hasVector())
 151                         throw badParamException();
 152                 vec->setVector(vec->getVector().scale(mag));
 153         }
 154
 155 /**
 156  * VEC: UNIT (vector) angle (decimal)
 157  * %status maybe
 158  *
 159  * Constructs and returns a unit vector with angle angle.
 160  *
 161  * Openc2e-only command,
 162  */
 163
 164         void caosVM::v_VEC_UNIT() {
 165                 VM_PARAM_FLOAT(angle)
 166
 167                 result.setVector(Vector<float>::unitVector(angle * PI / 180));
 168         }
 169
 170 /**
 171  * VEC: NULL (vector)
 172  * %status maybe
 173  *
 174  * Returns the nullary (0,0) vector.
 175  *
 176  * Openc2e-only command
 177  */
 178
 179         void caosVM::v_VEC_NULL() {
 180                 result.setVector(Vector<float>(0,0));
 181         }
 182
 183 /**
 184  * VEC: MAGN (float) vec (vector)
 185  * %status maybe
 186  *
 187  * Returns the magnitude of the passed vector.
 188  *
 189  * Openc2e-only command.
 190  */
 191         void caosVM::v_VEC_MAGN() {
 192                 VM_PARAM_VECTOR(vec)
 193
 194                 result.setFloat(vec.getMagnitude());
 195         }
 196
 197 /**
 198  * VEC: SETV (command) dest (variable) src (vector)
 199  * %status maybe
 200  *
 201  * Sets the variable passed in dest to the vector in src
 202  *
 203  * Openc2e-only command
 204  */
 205         void caosVM::c_VEC_SETV() {
 206                 VM_PARAM_VECTOR(src)
 207                 VM_PARAM_VARIABLE(dest)
 208
 209                 dest->setVector(src);
 210         }
 211
 212 /* vim: set noet: */