mirror of https://github.com/dirtbags/tanks.git
Clean compile of ctanks.c, but doubtless buggy as heck
This commit is contained in:
parent
4c3e1af017
commit
4720524639
159
brad.c
159
brad.c
|
|
@ -1,159 +0,0 @@
|
||||||
#include <stdlib.h>
|
|
||||||
#include "brad.h"
|
|
||||||
|
|
||||||
#ifndef max
|
|
||||||
#define max(a,b) (((a) > (b)) ? (a) : (b))
|
|
||||||
#define min(a,b) (((a) < (b)) ? (a) : (b))
|
|
||||||
#endif
|
|
||||||
|
|
||||||
/* Approximate vector length
|
|
||||||
*
|
|
||||||
* http://www.flipcode.com/archives/Fast_Approximate_Distance_Functions.shtml
|
|
||||||
*
|
|
||||||
* (1007/1024) * 256 == 251.75
|
|
||||||
* (441/1024) * 256 == 110.25
|
|
||||||
*/
|
|
||||||
bs_t
|
|
||||||
bs_approx_dist(bs_t dx, bs_t dy)
|
|
||||||
{
|
|
||||||
bs_t x = abs(dx);
|
|
||||||
bs_t y = abs(dy);
|
|
||||||
|
|
||||||
return (252 * max(x, y)) + (110 * min(x, y));
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
static bs_t bs_cos_table[] = {
|
|
||||||
256, 256, 256, 255, 255, 254, 253, 252,
|
|
||||||
251, 250, 248, 247, 245, 243, 241, 239,
|
|
||||||
237, 234, 231, 229, 226, 223, 220, 216,
|
|
||||||
213, 209, 206, 202, 198, 194, 190, 185,
|
|
||||||
181, 177, 172, 167, 162, 157, 152, 147,
|
|
||||||
142, 137, 132, 126, 121, 115, 109, 104,
|
|
||||||
98, 92, 86, 80, 74, 68, 62, 56,
|
|
||||||
50, 44, 38, 31, 25, 19, 13, 6,
|
|
||||||
0
|
|
||||||
};
|
|
||||||
|
|
||||||
bs_t
|
|
||||||
bs_cos(brad_t angle)
|
|
||||||
{
|
|
||||||
brad_t cos;
|
|
||||||
bs_t a;
|
|
||||||
|
|
||||||
a = abs(angle) % 128;
|
|
||||||
if (a > 64) {
|
|
||||||
a = 128 - a;
|
|
||||||
}
|
|
||||||
cos = bs_cos_table[a];
|
|
||||||
a = abs(angle) % 256;
|
|
||||||
if ((a > 64) && (a < 192)) {
|
|
||||||
cos = -cos;
|
|
||||||
}
|
|
||||||
return cos;
|
|
||||||
}
|
|
||||||
|
|
||||||
bs_t
|
|
||||||
bs_sin(brad_t angle)
|
|
||||||
{
|
|
||||||
return bs_cos(64 - angle);
|
|
||||||
}
|
|
||||||
|
|
||||||
bs_t
|
|
||||||
bs_tan(brad_t angle)
|
|
||||||
{
|
|
||||||
return bs_sin(angle) / bs_cos(angle);
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
static brad_t bs_asin_table[] = {
|
|
||||||
0, 0, 1, 1, 1, 2, 2, 2,
|
|
||||||
3, 3, 3, 4, 4, 4, 4, 5,
|
|
||||||
5, 5, 6, 6, 6, 7, 7, 7,
|
|
||||||
8, 8, 8, 9, 9, 9, 10, 10,
|
|
||||||
10, 11, 11, 11, 11, 12, 12, 12,
|
|
||||||
13, 13, 13, 14, 14, 14, 15, 15,
|
|
||||||
15, 16, 16, 16, 17, 17, 17, 18,
|
|
||||||
18, 18, 19, 19, 19, 20, 20, 20,
|
|
||||||
21, 21, 21, 22, 22, 22, 23, 23,
|
|
||||||
23, 24, 24, 24, 25, 25, 25, 26,
|
|
||||||
26, 26, 27, 27, 27, 28, 28, 28,
|
|
||||||
29, 29, 29, 30, 30, 30, 31, 31,
|
|
||||||
31, 32, 32, 32, 33, 33, 33, 34,
|
|
||||||
34, 34, 35, 35, 35, 36, 36, 37,
|
|
||||||
37, 37, 38, 38, 38, 39, 39, 39,
|
|
||||||
40, 40, 40, 41, 41, 42, 42, 42,
|
|
||||||
43, 43, 43, 44, 44, 45, 45, 45,
|
|
||||||
46, 46, 46, 47, 47, 48, 48, 48,
|
|
||||||
49, 49, 49, 50, 50, 51, 51, 51,
|
|
||||||
52, 52, 53, 53, 53, 54, 54, 55,
|
|
||||||
55, 55, 56, 56, 57, 57, 57, 58,
|
|
||||||
58, 59, 59, 60, 60, 60, 61, 61,
|
|
||||||
62, 62, 63, 63, 64, 64, 64, 65,
|
|
||||||
65, 66, 66, 67, 67, 68, 68, 69,
|
|
||||||
69, 70, 70, 71, 71, 72, 72, 73,
|
|
||||||
73, 74, 74, 75, 75, 76, 76, 77,
|
|
||||||
77, 78, 78, 79, 80, 80, 81, 81,
|
|
||||||
82, 82, 83, 84, 84, 85, 86, 86,
|
|
||||||
87, 87, 88, 89, 90, 90, 91, 92,
|
|
||||||
92, 93, 94, 95, 96, 96, 97, 98,
|
|
||||||
99, 100, 101, 102, 103, 104, 105, 106,
|
|
||||||
108, 109, 110, 112, 114, 116, 118, 121,
|
|
||||||
128
|
|
||||||
};
|
|
||||||
|
|
||||||
brad_t
|
|
||||||
bs_asin(bs_t n)
|
|
||||||
{
|
|
||||||
bs_t a = abs(n);
|
|
||||||
brad_t ret;
|
|
||||||
|
|
||||||
if (a > 256) {
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
ret = bs_asin_table[a];
|
|
||||||
if (n < 0) {
|
|
||||||
ret = -ret;
|
|
||||||
}
|
|
||||||
return ret;
|
|
||||||
}
|
|
||||||
|
|
||||||
brad_t
|
|
||||||
bs_acos(bs_t n)
|
|
||||||
{
|
|
||||||
return 128 - bs_asin(n);
|
|
||||||
}
|
|
||||||
|
|
||||||
brad_t
|
|
||||||
bs_atan2(bs_t y, bs_t x)
|
|
||||||
{
|
|
||||||
bs_t r = bs_approx_dist(x, y);
|
|
||||||
brad_t t;
|
|
||||||
|
|
||||||
t = bs_acos(x / r);
|
|
||||||
if (y < 0) {
|
|
||||||
t = 256 - t;
|
|
||||||
}
|
|
||||||
return t;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
#include <math.h>
|
|
||||||
#include <stdio.h>
|
|
||||||
#define PI 3.14159265358979323846
|
|
||||||
int
|
|
||||||
main()
|
|
||||||
{
|
|
||||||
int i, j;
|
|
||||||
float f;
|
|
||||||
int t;
|
|
||||||
|
|
||||||
for (i = 0; i < 257; i += 1) {
|
|
||||||
for (j = 0; j < 257; j += 1) {
|
|
||||||
f = sqrt(i*i + j*j);
|
|
||||||
t = bs_approx_dist(i, j);
|
|
||||||
printf("%d %d %d\n", i, (int)round(f*256)/256, t/256);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
50
brad.h
50
brad.h
|
|
@ -1,50 +0,0 @@
|
||||||
#ifndef __BRAD_H__
|
|
||||||
#define __BRAD_H__
|
|
||||||
|
|
||||||
/** Binary scaling library
|
|
||||||
*
|
|
||||||
* There are B8 binary scaled ints. That means the 8 lowest bits are
|
|
||||||
* the fractional part. To convert to a float you'd just divide by 256.
|
|
||||||
*
|
|
||||||
* The trig functions use brads (Binary Radians). There are 128 brads
|
|
||||||
* in 2pi radians. One brad is about 1.4 degrees. Using brads makes
|
|
||||||
* trig really fast on a binary computer, and reallier faster on a
|
|
||||||
* binary computer without an FPU.
|
|
||||||
*
|
|
||||||
* You must be careful not to overflow your bs_t. For instance, I wrote
|
|
||||||
* this library for a game with a 2^9-pixel-wide playfield. That's
|
|
||||||
* 2^17 B8, but I also needed to do distance calculations, which
|
|
||||||
* requires squaring things. 2^34 is obviously too big to represent in
|
|
||||||
* 32 bits.
|
|
||||||
*
|
|
||||||
* C's type system leaves a lot to be desired when it comes to making
|
|
||||||
* sure you're not mixing these things up with normal ints. Be careful!
|
|
||||||
*/
|
|
||||||
|
|
||||||
/* Just to make it clear what scale these functions are dealing with */
|
|
||||||
typedef struct {
|
|
||||||
int v;
|
|
||||||
} bs_t;
|
|
||||||
typedef int brad_t;
|
|
||||||
|
|
||||||
/* If you change this, you must also change the lookup tables in
|
|
||||||
* brad.c. Don't change this. */
|
|
||||||
#define BINARY_SCALE 8
|
|
||||||
#define BS_DENOMINATOR 1 << BINARY_SCALE
|
|
||||||
|
|
||||||
#define bs_to_int(n) ((n) >> BINARY_SCALE)
|
|
||||||
#define bs_of_int(i) ((i) << BINARY_SCALE)
|
|
||||||
|
|
||||||
bs_t bs_cos(brad_t angle);
|
|
||||||
bs_t bs_sin(brad_t angle);
|
|
||||||
bs_t bs_tan(brad_t angle);
|
|
||||||
|
|
||||||
brad_t bs_acos(bs_t angle);
|
|
||||||
brad_t bs_asin(bs_t angle);
|
|
||||||
|
|
||||||
bs_t bs_mul(bs_t a, bs_t b);
|
|
||||||
bs_t bs_div(bs_t a, bs_t b);
|
|
||||||
|
|
||||||
bs_t bs_approx_dist(bs_t dx, bs_t dy);
|
|
||||||
|
|
||||||
#endif /* __BRAD_H__ */
|
|
||||||
25
brad.py
25
brad.py
|
|
@ -1,25 +0,0 @@
|
||||||
#! /usr/bin/python
|
|
||||||
|
|
||||||
# Binary radians with B12 binary scaling (multiply floats by 256)
|
|
||||||
# pi radians = 128 brads
|
|
||||||
|
|
||||||
import math
|
|
||||||
|
|
||||||
brad2rad = math.pi/128
|
|
||||||
|
|
||||||
print "static bs_t bs_cos_table[] = {"
|
|
||||||
for i in range(129):
|
|
||||||
r = (i * math.pi) / 128.0
|
|
||||||
cos = math.sin(r)
|
|
||||||
bcos = int(round(cos * 256))
|
|
||||||
print ("%3d," % bcos),
|
|
||||||
print "}"
|
|
||||||
|
|
||||||
print "static brad_t bs_asin_table[] = {"
|
|
||||||
for i in range(257):
|
|
||||||
f = i / 256.0
|
|
||||||
acos = math.asin(f)
|
|
||||||
bacos = int(round(256 * acos / math.pi))
|
|
||||||
print ("%3d," % bacos),
|
|
||||||
print "}"
|
|
||||||
|
|
||||||
242
ctanks.c
242
ctanks.c
|
|
@ -1,6 +1,8 @@
|
||||||
#include <string.h>
|
#include <string.h>
|
||||||
#include <stdlib.h>
|
#include <stdlib.h>
|
||||||
#include "brad.h"
|
#include <stdio.h>
|
||||||
|
#include <math.h>
|
||||||
|
#include "trig.h"
|
||||||
#include "ctanks.h"
|
#include "ctanks.h"
|
||||||
|
|
||||||
void
|
void
|
||||||
|
|
@ -24,20 +26,20 @@ tank_fire(struct tank *tank)
|
||||||
}
|
}
|
||||||
|
|
||||||
void
|
void
|
||||||
tank_set_speed(struct tank *tank, bs_t left, bs_t right)
|
tank_set_speed(struct tank *tank, float left, float right)
|
||||||
{
|
{
|
||||||
tank->speed.desired[0] = left;
|
tank->speed.desired[0] = left;
|
||||||
tank->speed.desired[1] = right;
|
tank->speed.desired[1] = right;
|
||||||
}
|
}
|
||||||
|
|
||||||
brad_t
|
int
|
||||||
tank_get_turret(struct tank *tank)
|
tank_get_turret(struct tank *tank)
|
||||||
{
|
{
|
||||||
return tank->turret.current;
|
return tank->turret.current;
|
||||||
}
|
}
|
||||||
|
|
||||||
void
|
void
|
||||||
tank_set_turret(struct tank *tank, brad_t angle)
|
tank_set_turret(struct tank *tank, int angle)
|
||||||
{
|
{
|
||||||
tank->turret.desired = angle;
|
tank->turret.desired = angle;
|
||||||
}
|
}
|
||||||
|
|
@ -45,7 +47,7 @@ tank_set_turret(struct tank *tank, brad_t angle)
|
||||||
int
|
int
|
||||||
tank_get_sensor(struct tank *tank, int sensor_num)
|
tank_get_sensor(struct tank *tank, int sensor_num)
|
||||||
{
|
{
|
||||||
if ((sensor < 0) || (sensor > MAX_SENSORS)) {
|
if ((sensor_num < 0) || (sensor_num > TANK_MAX_SENSORS)) {
|
||||||
return 0;
|
return 0;
|
||||||
}
|
}
|
||||||
return tank->sensor[sensor_num].triggered;
|
return tank->sensor[sensor_num].triggered;
|
||||||
|
|
@ -57,24 +59,96 @@ tank_set_led(struct tank *tank, int active)
|
||||||
tank->led = active;
|
tank->led = active;
|
||||||
}
|
}
|
||||||
|
|
||||||
/** Return distance^2 between tanks a and b.
|
static void
|
||||||
*
|
rotate_point(int angle, float point[2])
|
||||||
* Comparing this against sensor_range^2 will tell you whether the tanks
|
|
||||||
* are within sensor range of one another. Similarly, comparing it
|
|
||||||
* against (2*tank_radius)^2 will tell you if they've collided.
|
|
||||||
*
|
|
||||||
*/
|
|
||||||
bs_t
|
|
||||||
tank_dist2(struct tanks_game *game, struct tank *a, struct tank *b)
|
|
||||||
{
|
{
|
||||||
bs_t d[2];
|
float cos_, sin_;
|
||||||
|
float new[2];
|
||||||
|
|
||||||
|
cos_ = trig_cos(angle);
|
||||||
|
sin_ = trig_sin(angle);
|
||||||
|
|
||||||
|
new[0] = point[0]*cos_ + point[1]*sin_;
|
||||||
|
new[1] = point[0]*sin_ + point[1]*cos_;
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
static void
|
||||||
|
tank_sensor_calc(struct tanks_game *game,
|
||||||
|
struct tank *this,
|
||||||
|
struct tank *that,
|
||||||
|
float dist2)
|
||||||
|
{
|
||||||
|
float tpos[2];
|
||||||
int i;
|
int i;
|
||||||
|
|
||||||
|
/* Translate other tank's position to make us the origin */
|
||||||
for (i = 0; i < 2; i += 1) {
|
for (i = 0; i < 2; i += 1) {
|
||||||
d[i] = abs(a.position[i] - b.position[i]);
|
tpos[i] = that->position[i] - this->position[i];
|
||||||
d[i] = min(game.size[i] - dx[i], dx[i]);
|
}
|
||||||
|
|
||||||
|
/* Did this shoot that? Rotate point by turret degrees, and if |y| <
|
||||||
|
TANK_RADIUS, we have a hit. */
|
||||||
|
if ((this->turret.firing) && (dist2 <= TANK_CANNON_RANGE)) {
|
||||||
|
int theta = this->angle + this->turret.current;
|
||||||
|
float rpos[2];
|
||||||
|
|
||||||
|
rpos[0] = tpos[0];
|
||||||
|
rpos[1] = tpos[1];
|
||||||
|
rotate_point(theta, rpos);
|
||||||
|
if (fabsf(rpos[1]) < TANK_RADIUS) {
|
||||||
|
that->killer = this;
|
||||||
|
that->cause_death = "shot";
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/* Calculate sensors */
|
||||||
|
for (i = 0; i < this->num_sensors; i += 1) {
|
||||||
|
int theta;
|
||||||
|
float rpos[2];
|
||||||
|
float m_r, m_s;
|
||||||
|
|
||||||
|
/* No need to re-check this sensor if it's already firing */
|
||||||
|
if (this->sensor[i].triggered) {
|
||||||
|
continue;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* If the tank is out of range, don't bother */
|
||||||
|
if (dist2 < this->sensor[i].range_adj2) {
|
||||||
|
continue;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* What is the angle of our sensor? */
|
||||||
|
theta = this->angle;
|
||||||
|
if (this->sensor[i].turret) {
|
||||||
|
theta += this->turret.current;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* Rotate tpos by theta */
|
||||||
|
rpos[0] = tpos[0];
|
||||||
|
rpos[1] = tpos[1];
|
||||||
|
rotate_point(theta, rpos);
|
||||||
|
|
||||||
|
/* Sensor is symmetrical, we can consider only first quadrant */
|
||||||
|
rpos[1] = fabsf(rpos[1]);
|
||||||
|
|
||||||
|
/* Compute slopes to tank and of our sensor */
|
||||||
|
m_s = tan(theta);
|
||||||
|
m_r = rpos[1] / rpos[0];
|
||||||
|
|
||||||
|
/* If their slope is greater than ours, they're inside the arc */
|
||||||
|
if (m_r >= m_s) {
|
||||||
|
this->sensor[i].triggered = 1;
|
||||||
|
continue;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* Now check if the edge of the arc intersects the tank. Do this
|
||||||
|
just like with firing. */
|
||||||
|
rotate_point(this->sensor[i].width / 2, rpos);
|
||||||
|
if (fabsf(rpos[1]) < TANK_RADIUS) {
|
||||||
|
this->sensor[i].triggered = 1;
|
||||||
|
}
|
||||||
}
|
}
|
||||||
return ((d[0] * d[0]) + (d[1] * d[1]));
|
|
||||||
}
|
}
|
||||||
|
|
||||||
void
|
void
|
||||||
|
|
@ -82,9 +156,9 @@ do_shit_with(struct tanks_game *game,
|
||||||
struct tank *this,
|
struct tank *this,
|
||||||
struct tank *that)
|
struct tank *that)
|
||||||
{
|
{
|
||||||
bs_t vector[2];
|
float vector[2];
|
||||||
int dist2; /* Integer to avoid overflow! */
|
int dist2; /* Integer to avoid overflow! */
|
||||||
bs_t xpos; /* Translated position */
|
float tpos; /* Translated position */
|
||||||
int i;
|
int i;
|
||||||
|
|
||||||
/* Don't bother if one is dead */
|
/* Don't bother if one is dead */
|
||||||
|
|
@ -95,7 +169,7 @@ do_shit_with(struct tanks_game *game,
|
||||||
/* Establish shortest vector from center of this to center of that,
|
/* Establish shortest vector from center of this to center of that,
|
||||||
* taking wrapping into account */
|
* taking wrapping into account */
|
||||||
for (i = 0; i < 2; i += 1) {
|
for (i = 0; i < 2; i += 1) {
|
||||||
bs_t halfsize = game->size[i] / 2;
|
float halfsize = game->size[i] / 2;
|
||||||
|
|
||||||
/* XXX: is there a more elegant way to do this? */
|
/* XXX: is there a more elegant way to do this? */
|
||||||
vector[i] = that->position[i] - this->position[i];
|
vector[i] = that->position[i] - this->position[i];
|
||||||
|
|
@ -106,37 +180,133 @@ do_shit_with(struct tanks_game *game,
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
/* Compute distance^2 for range comparisons */
|
/* Compute distance^2 for range comparisons */
|
||||||
dist2 = ((bs_to_int(vector[0]) * bs_to_int(vector[0])) +
|
dist2 = ((vector[0] * vector[0]) + (vector[1] * vector[1]));
|
||||||
(bs_to_int(vector[1]) * bs_to_int(vector[1])));
|
|
||||||
|
|
||||||
/* If they're not within sensor range, there's nothing to do. */
|
/* If they're not within sensor range, there's nothing to do. */
|
||||||
if (dist2 > TANK_SENSOR_ADJ2) {
|
if (dist2 > TANK_SENSOR_ADJ2) {
|
||||||
return;
|
return;
|
||||||
}
|
}
|
||||||
|
|
||||||
/* Did they collide? Oh, goody! */
|
/* Did they collide? */
|
||||||
if (dist2 < TANK_COLLISION_ADJ2) {
|
if (dist2 < TANK_COLLISION_ADJ2) {
|
||||||
/* XXX: kill both tanks */
|
this->killer = that;
|
||||||
|
this->cause_death = "collision";
|
||||||
|
|
||||||
|
that->killer = this;
|
||||||
|
this->cause_death = "collision";
|
||||||
|
|
||||||
return;
|
return;
|
||||||
}
|
}
|
||||||
|
|
||||||
/* Has anybody been shot? */
|
/* Figure out who's whomin' whom */
|
||||||
|
tank_sensor_calc(game, this, that, dist2);
|
||||||
|
tank_sensor_calc(game, that, this, dist2);
|
||||||
|
}
|
||||||
|
|
||||||
/* Translate other tank's position to make us the origin */
|
void
|
||||||
|
tanks_print_tank(struct tanks_game *game,
|
||||||
|
struct tank *tank)
|
||||||
|
{
|
||||||
|
printf("%p\n", tank);
|
||||||
|
}
|
||||||
|
|
||||||
|
void
|
||||||
|
tanks_move_tank(struct tanks_game *game,
|
||||||
|
struct tank *tank)
|
||||||
|
{
|
||||||
|
int i;
|
||||||
|
float movement[2];
|
||||||
|
int angle;
|
||||||
|
|
||||||
|
/* Fakey acceleration */
|
||||||
for (i = 0; i < 2; i += 1) {
|
for (i = 0; i < 2; i += 1) {
|
||||||
xpos[i] = that->position[i] - this->position[i];
|
if (tank->speed.current[i] == tank->speed.desired[i]) {
|
||||||
|
/* Do nothing */
|
||||||
|
} else if (tank->speed.current[i] < tank->speed.desired[i]) {
|
||||||
|
tank->speed.current[i] = max(tank->speed.current[i] - TANK_MAX_ACCEL,
|
||||||
|
tank->speed.desired[i]);
|
||||||
|
} else {
|
||||||
|
tank->speed.current[i] = min(tank->speed.current[i] + TANK_MAX_ACCEL,
|
||||||
|
tank->speed.desired[i]);
|
||||||
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
/* Calculate sensors */
|
/* The simple case */
|
||||||
for (i = 0; i < this->num_sensors; i += 1) {
|
if (tank->speed.current[0] == tank->speed.current[1]) {
|
||||||
brad_t theta;
|
movement[0] = tank->speed.current[0];
|
||||||
|
movement[1] = tank->speed.current[1];
|
||||||
|
angle = tank->angle;
|
||||||
|
} else {
|
||||||
|
/* pflarr's original comment:
|
||||||
|
*
|
||||||
|
* The tank drives around in a circle of radius r, which is some *
|
||||||
|
* offset on a line perpendicular to the tank. The distance it
|
||||||
|
* travels around the circle varies with the speed of each tread,
|
||||||
|
* and is such that each side of the tank moves an equal angle
|
||||||
|
* around the circle.
|
||||||
|
*
|
||||||
|
* Sounds good to me. pflarr's calculations here are fantastico,
|
||||||
|
* there's nothing whatsoever to change. */
|
||||||
|
float friction;
|
||||||
|
float v[2];
|
||||||
|
float So, Si;
|
||||||
|
float w, r;
|
||||||
|
int theta;
|
||||||
|
int dir;
|
||||||
|
|
||||||
if (dist2 < this->sensor[i].range_adj2) {
|
/* The first thing Paul's code does is find "friction", which seems
|
||||||
continue;
|
to be a penalty for having the treads go in opposite directions.
|
||||||
|
This probably plays hell with precisely-planned tanks, which I
|
||||||
|
find very ha ha. */
|
||||||
|
friction = .25 * (fabsf(tank->speed.current[0] - tank->speed.current[1]) / 200);
|
||||||
|
|
||||||
|
v[0] = tank->speed.current[0] * friction;
|
||||||
|
v[1] = tank->speed.current[1] * friction;
|
||||||
|
|
||||||
|
/* Outside and inside speeds */
|
||||||
|
So = max(v[0], v[1]);
|
||||||
|
Si = min(v[0], v[1]);
|
||||||
|
dir = (v[0] > v[1]) ? 1 : -1;
|
||||||
|
|
||||||
|
/* Width of tank */
|
||||||
|
w = TANK_RADIUS * 2;
|
||||||
|
|
||||||
|
/* Radius of circle to outside tread (use similar triangles) */
|
||||||
|
r = So * w / (So - Si);
|
||||||
|
|
||||||
|
/* pflarr:
|
||||||
|
|
||||||
|
The fraction of the circle traveled is equal to the speed
|
||||||
|
of the outer tread over the circumference of the circle:
|
||||||
|
Ft = So/(2*pi*r)
|
||||||
|
The angle traveled is:
|
||||||
|
theta = Ft * 2*pi
|
||||||
|
This reduces to a simple
|
||||||
|
theta = So/r
|
||||||
|
We multiply it by dir to adjust for the direction of rotation
|
||||||
|
*/
|
||||||
|
theta = rad2deg(So/r) * dir;
|
||||||
|
|
||||||
|
/* Translate so the circle's center is 0,0, rotate the point by
|
||||||
|
theta, then add back in. */
|
||||||
|
v[0] = trig_cos(tank->angle + 90*dir) * (TANK_RADIUS - r);
|
||||||
|
v[1] = trig_sin(tank->angle + 90*dir) * (TANK_RADIUS - r);
|
||||||
|
|
||||||
|
movement[0] = v[0];
|
||||||
|
movement[1] = v[1];
|
||||||
|
rotate_point(theta, movement);
|
||||||
|
|
||||||
|
movement[0] -= v[0];
|
||||||
|
movement[1] -= v[1];
|
||||||
|
angle = theta;
|
||||||
}
|
}
|
||||||
|
|
||||||
/* Translate other tank so that we're the origin */
|
/* Now move the tank */
|
||||||
|
for (i = 0; i < 2; i += 1) {
|
||||||
|
tank->position[i] = fmodf(tank->position[i] + movement[i] + game->size[i],
|
||||||
|
game->size[i]);
|
||||||
}
|
}
|
||||||
|
tank->angle = (tank->angle + angle + 360) % 360;
|
||||||
}
|
}
|
||||||
|
|
||||||
void
|
void
|
||||||
|
|
@ -145,10 +315,10 @@ tanks_run_turn(struct tanks_game *game, struct tank *tanks, int ntanks)
|
||||||
int i, j;
|
int i, j;
|
||||||
|
|
||||||
for (i = 0; i < ntanks; i += 1) {
|
for (i = 0; i < ntanks; i += 1) {
|
||||||
for (j = i + 1; j < ntanks, j += 1) {
|
for (j = i + 1; j < ntanks; j += 1) {
|
||||||
do_shit_with(game, &(tanks[i]), &(tanks[j]));
|
do_shit_with(game, &(tanks[i]), &(tanks[j]));
|
||||||
}
|
}
|
||||||
tanks_print_tank(game, &(tanks[i]));
|
tanks_print_tank(game, &(tanks[i]));
|
||||||
tanks_move(game, &(tanks[i]));
|
tanks_move_tank(game, &(tanks[i]));
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
|
||||||
39
ctanks.h
39
ctanks.h
|
|
@ -1,33 +1,34 @@
|
||||||
#ifndef __CTANKS_H__
|
#ifndef __CTANKS_H__
|
||||||
#define __CTANKS_H__
|
#define __CTANKS_H__
|
||||||
|
|
||||||
#include "brad.h"
|
|
||||||
|
|
||||||
/* Some useful constants */
|
/* Some useful constants */
|
||||||
#define TANK_MAX_SENSORS 10
|
#define TANK_MAX_SENSORS 10
|
||||||
#define TANK_RADIUS ((bs_t)1920)
|
#define TANK_RADIUS 7.5
|
||||||
#define TANK_SENSOR_RANGE ((int)100)
|
#define TANK_SENSOR_RANGE 100
|
||||||
|
#define TANK_CANNON_RANGE (TANK_SENSOR_RANGE / 2)
|
||||||
|
#define TANK_MAX_ACCEL 35
|
||||||
|
|
||||||
/* (tank radius + tank radius)^2 */
|
/* (tank radius + tank radius)^2 */
|
||||||
#define TANK_COLLISION_ADJ2 \
|
#define TANK_COLLISION_ADJ2 \
|
||||||
bs_to_int((TANK_RADIUS + TANK_RADIUS) * (TANK_RADIUS + TANK_RADIUS))
|
((TANK_RADIUS + TANK_RADIUS) * (TANK_RADIUS + TANK_RADIUS))
|
||||||
|
|
||||||
/* (Sensor range + tank radius)^2
|
/* (Sensor range + tank radius)^2
|
||||||
* If the distance^2 to the center of a tank <= TANK_SENSOR_ADJ2,
|
* If the distance^2 to the center of a tank <= TANK_SENSOR_ADJ2,
|
||||||
* that tank is within sensor range. */
|
* that tank is within sensor range. */
|
||||||
#define TANK_SENSOR_ADJ2 ((int)11556)
|
#define TANK_SENSOR_ADJ2 \
|
||||||
|
((TANK_SENSOR_RANGE + TANK_RADIUS) * (TANK_SENSOR_RANGE + TANK_RADIUS))
|
||||||
|
|
||||||
struct tanks_game {
|
struct tanks_game {
|
||||||
bs_t size[2]; /* dimensions of playing field */
|
float size[2]; /* dimensions of playing field */
|
||||||
};
|
};
|
||||||
|
|
||||||
struct tank;
|
struct tank;
|
||||||
|
|
||||||
struct sensor {
|
struct sensor {
|
||||||
brad_t angle;
|
int angle;
|
||||||
brad_t width;
|
int width;
|
||||||
int range;
|
float range;
|
||||||
int range_adj2; /* (range + TANK_RADIUS)^2 */
|
float range_adj2; /* (range + TANK_RADIUS)^2 */
|
||||||
int turret; /* Mounted to turret? */
|
int turret; /* Mounted to turret? */
|
||||||
int triggered;
|
int triggered;
|
||||||
};
|
};
|
||||||
|
|
@ -35,19 +36,19 @@ struct sensor {
|
||||||
typedef void tank_run_func(struct tank *, void *);
|
typedef void tank_run_func(struct tank *, void *);
|
||||||
|
|
||||||
struct tank {
|
struct tank {
|
||||||
bs_t position[2]; /* Current position on the board */
|
float position[2]; /* Current position on the board */
|
||||||
brad_t angle; /* Current orientation */
|
int angle; /* Current orientation */
|
||||||
struct {
|
struct {
|
||||||
bs_t current[2]; /* Current tread speed */
|
float current[2]; /* Current tread speed */
|
||||||
bs_t desired[2]; /* Desired tread speed */
|
float desired[2]; /* Desired tread speed */
|
||||||
} speed;
|
} speed;
|
||||||
struct {
|
struct {
|
||||||
brad_t current; /* Current turret angle */
|
int current; /* Current turret angle */
|
||||||
brad_t desired; /* Desired turret angle */
|
int desired; /* Desired turret angle */
|
||||||
int firing; /* True if firing this turn */
|
int firing; /* True if firing this turn */
|
||||||
int recharge; /* Turns until gun is recharged */
|
int recharge; /* Turns until gun is recharged */
|
||||||
} turret;
|
} turret;
|
||||||
struct sensor sensor[MAX_SENSORS]; /* Sensor array */
|
struct sensor sensor[TANK_MAX_SENSORS]; /* Sensor array */
|
||||||
int num_sensors; /* Number of sensors */
|
int num_sensors; /* Number of sensors */
|
||||||
int led; /* State of the LED */
|
int led; /* State of the LED */
|
||||||
struct tank *killer; /* Killer, or NULL if alive */
|
struct tank *killer; /* Killer, or NULL if alive */
|
||||||
|
|
@ -72,7 +73,7 @@ int tank_fire_ready(struct tank *tank);
|
||||||
void tank_fire(struct tank *tank);
|
void tank_fire(struct tank *tank);
|
||||||
|
|
||||||
/** Set desired speed */
|
/** Set desired speed */
|
||||||
void tank_set_speed(struct tank *tank, int left, int right);
|
void tank_set_speed(struct tank *tank, float left, float right);
|
||||||
|
|
||||||
/** Get the current turret angle */
|
/** Get the current turret angle */
|
||||||
int tank_get_turret(struct tank *tank);
|
int tank_get_turret(struct tank *tank);
|
||||||
|
|
|
||||||
|
|
@ -0,0 +1,93 @@
|
||||||
|
#include <stdlib.h>
|
||||||
|
#include <math.h>
|
||||||
|
#include "trig.h"
|
||||||
|
|
||||||
|
#ifndef max
|
||||||
|
#define max(a,b) (((a) > (b)) ? (a) : (b))
|
||||||
|
#define min(a,b) (((a) < (b)) ? (a) : (b))
|
||||||
|
#endif
|
||||||
|
|
||||||
|
static float trig_cos_table[] = {
|
||||||
|
1.000000, 0.999848, 0.999391, 0.998630, 0.997564, 0.996195,
|
||||||
|
0.994522, 0.992546, 0.990268, 0.987688, 0.984808, 0.981627,
|
||||||
|
0.978148, 0.974370, 0.970296, 0.965926, 0.961262, 0.956305,
|
||||||
|
0.951057, 0.945519, 0.939693, 0.933580, 0.927184, 0.920505,
|
||||||
|
0.913545, 0.906308, 0.898794, 0.891007, 0.882948, 0.874620,
|
||||||
|
0.866025, 0.857167, 0.848048, 0.838671, 0.829038, 0.819152,
|
||||||
|
0.809017, 0.798636, 0.788011, 0.777146, 0.766044, 0.754710,
|
||||||
|
0.743145, 0.731354, 0.719340, 0.707107, 0.694658, 0.681998,
|
||||||
|
0.669131, 0.656059, 0.642788, 0.629320, 0.615661, 0.601815,
|
||||||
|
0.587785, 0.573576, 0.559193, 0.544639, 0.529919, 0.515038,
|
||||||
|
0.500000, 0.484810, 0.469472, 0.453990, 0.438371, 0.422618,
|
||||||
|
0.406737, 0.390731, 0.374607, 0.358368, 0.342020, 0.325568,
|
||||||
|
0.309017, 0.292372, 0.275637, 0.258819, 0.241922, 0.224951,
|
||||||
|
0.207912, 0.190809, 0.173648, 0.156434, 0.139173, 0.121869,
|
||||||
|
0.104528, 0.087156, 0.069756, 0.052336, 0.034899, 0.017452,
|
||||||
|
0.000000,
|
||||||
|
};
|
||||||
|
|
||||||
|
float
|
||||||
|
trig_cos(int angle)
|
||||||
|
{
|
||||||
|
int a;
|
||||||
|
float ret;
|
||||||
|
|
||||||
|
a = abs(angle) % 180;
|
||||||
|
if (a > 90) {
|
||||||
|
a = 180 - a;
|
||||||
|
}
|
||||||
|
ret = trig_cos_table[a];
|
||||||
|
a = abs(angle) % 360;
|
||||||
|
if ((a > 90) && (a < 270)) {
|
||||||
|
ret = -ret;
|
||||||
|
}
|
||||||
|
return ret;
|
||||||
|
}
|
||||||
|
|
||||||
|
float
|
||||||
|
trig_sin(int angle)
|
||||||
|
{
|
||||||
|
return trig_cos(90 - angle);
|
||||||
|
}
|
||||||
|
|
||||||
|
float
|
||||||
|
trig_tan(int angle)
|
||||||
|
{
|
||||||
|
return trig_sin(angle) / trig_cos(angle);
|
||||||
|
}
|
||||||
|
|
||||||
|
int
|
||||||
|
trig_asin(float x)
|
||||||
|
{
|
||||||
|
return rad2deg(asinf(x));
|
||||||
|
}
|
||||||
|
|
||||||
|
int
|
||||||
|
trig_acos(float x)
|
||||||
|
{
|
||||||
|
return rad2deg(acosf(x));
|
||||||
|
}
|
||||||
|
|
||||||
|
int
|
||||||
|
trig_atan2(float y, float x)
|
||||||
|
{
|
||||||
|
return rad2deg(atan2f(y, x));
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
#if 0
|
||||||
|
#include <stdio.h>
|
||||||
|
|
||||||
|
int
|
||||||
|
main()
|
||||||
|
{
|
||||||
|
int i, j;
|
||||||
|
float f;
|
||||||
|
int t;
|
||||||
|
|
||||||
|
for (i = 0; i < 600; i += 1) {
|
||||||
|
printf("%-04d %-0.6f %-0.6f\n", i, trig_cos(i), cosf(deg2rad(i)));
|
||||||
|
}
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
#endif
|
||||||
|
|
@ -0,0 +1,25 @@
|
||||||
|
#ifndef __TRIG_H__
|
||||||
|
#define __TRIG_H__
|
||||||
|
|
||||||
|
/** Trigonometry in degrees
|
||||||
|
*
|
||||||
|
* It's just a library to do discrete(-ish) trig, using degrees. It
|
||||||
|
* uses a lookup table to make sin, cos, and tan really fast.
|
||||||
|
* Everything is as slow as normal :)
|
||||||
|
*/
|
||||||
|
|
||||||
|
/* Just to make it clear what scale these functions are dealing with */
|
||||||
|
#define PI 3.14159265358979323846
|
||||||
|
|
||||||
|
#define rad2deg(rad) ((int)(rad * 180 / PI))
|
||||||
|
#define deg2rad(deg) ((float)(deg * PI / 180))
|
||||||
|
|
||||||
|
float trig_cos(int angle);
|
||||||
|
float trig_sin(int angle);
|
||||||
|
float trig_atan(int angle);
|
||||||
|
|
||||||
|
int trig_acos(float angle);
|
||||||
|
int trig_asin(float angle);
|
||||||
|
int trig_atan2(float y, float x);
|
||||||
|
|
||||||
|
#endif /* __TRIG_H__ */
|
||||||
Loading…
Reference in New Issue