trunk/src/breve/Celdas.tz

   1 @use PhysicalControl.
   2 @use Shape.
   3 @use Stationary.
   4 @use Link.
   5 @use MultiBody.
   6
   7 PhysicalControl : CeldasControl {
   8         % This class is used for building simple vehicle
   9         % simulations.  To create a vehicle simulation,
  10         % subclass CeldasControl and use the init method to
  11         % create OBJECT(CeldasObstacle) and
  12         % OBJECT(CeldasVehicle) objects.
  13
  14         + variables:
  15                 floor (object).
  16                 floorShape (object).
  17                 cloudTexture (object).
  18
  19         + to init:
  20                 self enable-lighting.
  21                 #self enable-smooth-drawing.
  22
  23                 floorShape = new Shape.
  24                 floorShape init-with-cube size (200, .2, 200).
  25
  26                 floor = new Stationary.
  27                 floor register with-shape floorShape at-location (0, 0, 0).
  28                 #floor catch-shadows.
  29
  30                 self point-camera at (0, 0, 0) from (3, 3, 24).
  31
  32                 #self enable-shadows.
  33                 #self enable-reflections.
  34
  35                 cloudTexture = (new Image load from "images/clouds.png").
  36                 self set-background-color to (.4, .6, .9).
  37                 self set-background-texture-image to cloudTexture.
  38 }
  39
  40 MultiBody : CeldasLightVehicle (aka CeldasLightVehicles) {
  41         % This object is used in conjunction with OBJECT(CeldasControl) to
  42         % create simple vehicles.
  43
  44         + variables:
  45                 bodyShape (object).
  46                 wheelShape (object).
  47                 sensorShape (object).
  48                 bodyLink (object).
  49
  50                 wheels (list).
  51                 sensors (list).
  52
  53         + to init:
  54                 bodyShape = new Shape.
  55                 bodyShape init-with-cube size (4.0, .75, 3.0).
  56
  57                 wheelShape = new Shape.
  58                 wheelShape init-with-polygon-disk radius ( self get-wheel-radius ) sides 20 height ( self get-wheel-width ).
  59                 # 40
  60
  61                 sensorShape = new Shape.
  62                 sensorShape init-with-polygon-cone radius .2 sides 5 height .5.
  63                 # 10
  64
  65                 bodyShape set-density to ( self get-density ).
  66                 bodyLink = new Link.
  67                 bodyLink set-shape to bodyShape.
  68                 bodyLink set-mu to -1.0.
  69                 bodyLink set-eT to .8.
  70
  71                 self set-root to bodyLink.
  72
  73                 self move to (0, 0.9, 0).
  74                 self set-texture-scale to 1.5.
  75
  76         - to get-density:
  77                 return 1.0.
  78
  79         - to get-wheel-width:
  80                 return 0.1.
  81
  82         - to get-wheel-radius:
  83                 return 0.6.
  84
  85         + section "Adding Wheels and Sensors to a Vehicle"
  86
  87         + to add-wheel at location (vector):
  88                 % Adds a wheel at location on the vehicle.  This method returns
  89                 % the wheel which is created, a OBJECT(CeldasWheel).
  90
  91                 wheel, joint (object).
  92
  93                 wheel = new CeldasWheel.
  94                 wheel set-shape to wheelShape.
  95
  96                 joint = new RevoluteJoint.
  97
  98                 joint set-relative-rotation around-axis (1, 0, 0) by 1.5708.
  99                 joint link parent bodyLink to-child wheel with-normal (0, 0, 1)
 100                                         with-parent-point location with-child-point (0, 0, 0).
 101
 102                 wheel set-eT to .8.
 103                 wheel set-texture to 0.
 104                 wheel set-joint to joint.
 105                 joint set-strength-limit to (joint get-strength-hard-limit) / 2.
 106                 wheel set-color to (.6, .6, .6).
 107                 wheel set-mu to 100000.
 108
 109                 self add-dependency on joint.
 110                 self add-dependency on wheel.
 111
 112                 push wheel onto wheels.
 113
 114                 return wheel.
 115
 116         + to add-sensor at location (vector):
 117                 % Adds a sensor at location on the vehicle.  This method returns
 118                 % the sensor which is created, a OBJECT(CeldasSensor).
 119
 120                 sensor, joint (object).
 121
 122                 sensor = new CeldasSensor.
 123                 sensor set-shape to sensorShape.
 124
 125                 joint = new RevoluteJoint.
 126
 127                 joint set-relative-rotation around-axis (0, 0, 1) by -1.57.
 128                 joint link parent bodyLink to-child sensor with-normal (1, 0, 0)
 129                                         with-parent-point location with-child-point (0, 0, 0).
 130
 131                 joint set-double-spring with-strength 300 with-max 0.01 with-min -0.01.
 132
 133                 self add-dependency on joint.
 134                 self add-dependency on sensor.
 135
 136                 sensor set-color to (0, 0, 0).
 137
 138                 push sensor onto sensors.
 139
 140                 return sensor.
 141
 142         + to destroy:
 143                 free sensorShape.
 144                 free wheelShape.
 145                 free bodyShape.
 146
 147                 super destroy.
 148 }
 149
 150 CeldasLightVehicle : CeldasVehicle (aka CeldasVehicles) {
 151         % A heavy duty version of OBJECT(CeldasLightVehicle), this
 152         % vehicle is heavier and harder to control, but more stable
 153         % at higher speeds.
 154
 155         - to get-density:
 156                 return 20.0.
 157
 158         - to get-wheel-width:
 159                 return 0.4.
 160
 161         - to get-wheel-radius:
 162                 return 0.8.
 163 }
 164
 165 Stationary : CeldasObstacle (aka CeldasObstacles) {
 166         % A CeldasObstacle is used in conjunction with OBJECT(CeldasControl)
 167         % and OBJECT(CeldasVehicle).  It is what the OBJECT(CeldasSensor)
 168         % objects on the CeldasVehicle detect.
 169         % <p>
 170         % There are no special behaviors associated with the walls--they're
 171         % basically just plain OBJECT(Stationary) objects.
 172
 173         + to init with-size theSize = (10, 3, .1) (vector) with-color theColor = (1, 0, 0) (vector) at-location theLocation = (0, 0, 0) (vector) with-rotation theRotation = [ ( 0, 0, 1 ), ( 0, 1, 0 ), ( 1, 0, 0 ) ] (matrix):
 174                 self init-with-shape shape (new Shape init-with-cube size theSize) color theColor at-location theLocation with-rotation theRotation.
 175
 176         + to init-with-shape shape theShape (object) color theColor = (1, 0, 0) (vector) at-location theLocation = (0, 0, 0) (vector) with-rotation theRotation = [ ( 1, 0, 0 ), ( 0, 1, 0 ), ( 0, 0, 1 ) ] (matrix):
 177                 self register with-shape theShape at-location theLocation with-rotation theRotation.
 178                 self set-color to theColor.
 179 }
 180
 181 Link : CeldasWheel (aka CeldasWheels) {
 182         % A CeldasWheel is used in conjunction with OBJECT(CeldasVehicle)
 183         % to build Celdas vehicles.  This class is typically not instantiated
 184         % manually, since OBJECT(CeldasVehicle) creates one for you when you
 185         % add a wheel to the vehicle.
 186
 187         + variables:
 188                 joint (object).
 189
 190         - to set-joint to j (object):
 191                 % Used internally.
 192
 193                 joint = j.
 194
 195         + section "Configuring the Wheel's Velocity"
 196
 197         + to set-velocity to n (float):
 198                 % Sets the velocity of this wheel.
 199
 200                 joint set-joint-velocity to n.
 201
 202         + to get-velocity:
 203                 % Gets the velocity of this wheel.
 204
 205                 return (joint get-joint-velocity).
 206
 207 }
 208
 209 Link : CeldasSensor (aka CeldasSensors) {
 210         % A CeldasSensor is used in conjunction with OBJECT(CeldasVehicle)
 211         % to build Celdas vehicles.  This class is typically not instantiated
 212         % manually, since OBJECT(CeldasVehicle) creates one for you when you
 213         % add a sensor to the vehicle.
 214
 215         + variables:
 216                 direction (vector).
 217                 sensorAngle (float).
 218                 value (float).
 219
 220         + to init:
 221                 direction = (0, 1, 0).
 222                 sensorAngle = 1.6.
 223                 value = 0.0.
 224
 225   + section "Configuring the Sensor Values"
 226
 227         + to set-sensor-angle to n (float):
 228                 % Sets the angle in which this sensor can detect obstacles.  The default
 229                 % value of 1.6 means that the sensor can see most of everything in
 230                 % front of it.  Setting the value to be any higher leads to general
 231                 % wackiness, so I don't suggest it.
 232
 233                 sensorAngle = n.
 234
 235   + section "Getting the Sensor Values"
 236
 237         + to get-sensor-value:
 238                 % Gets the sensor value. This should be used from post-iterate,
 239                 % if not, the sensor reading correspond to the previous
 240                 % iteration.
 241
 242                 return value.
 243
 244         + to iterate:
 245                 i (object).
 246                 strength, angle (float).
 247                 toObstacle, transDir (vector).
 248
 249                 transDir = (self get-rotation) * direction.
 250
 251                 value = 0.0.
 252
 253                 foreach i in (all CeldasObstacles): {
 254                         toObstacle = (i get-location) - (self get-location).
 255                         angle = angle(toObstacle, transDir).
 256
 257                         if angle < sensorAngle: {
 258                                 strength = | (self get-location) - (i get-location) |.
 259                                 strength = 100.0 / (strength * strength) .
 260
 261                                 if strength > value: value = strength.
 262                         }
 263                 }
 264
 265 }