trunk/src/breve/Celdas.tz

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