Previous 15994 Revisions Next

r2387 Sunday 13th April, 2008 at 12:15:20 UTC by Mathis Rosenhauer
- New screen refresh method for Vectrex
- Bug 1034 fixed. Not with multiscreen functions
from MAME, though, as they crash MESS (No vector support?)
- Many small changes to bring the driver up-to-date
with modern MAME

TODO: Get rid of fake dipswitches
[src/mess/drivers]vectrex.c
[src/mess/includes]vectrex.h
[src/mess/machine]vectrex.c
[src/mess/video]vectrex.c

src/mess/includes/vectrex.h
r2386r2387
1818extern double imager_freq;
1919extern emu_timer *imager_timer;
2020extern int vectrex_lightpen_port;
21extern UINT8 *vectrex_ram_base;
22extern size_t vectrex_ram_size;
21extern int vectrex_reset_refresh;
2322
24TIMER_CALLBACK(vectrex_imager_right_eye);
23TIMER_CALLBACK(vectrex_imager_eye);
2524void vectrex_configuration(void);
2625READ8_HANDLER (v_via_pa_r);
2726READ8_HANDLER(v_via_pb_r );
r2386r2387
4241VIDEO_START( raaspec );
4342
4443WRITE8_HANDLER  ( raaspec_led_w );
44WRITE8_HANDLER ( vectrex_via_w );
4545
4646void vectrex_add_point_stereo (int x, int y, rgb_t color, int intensity);
4747void vectrex_add_point (int x, int y, rgb_t color, int intensity);
4848extern void (*vector_add_point_function) (int, int, rgb_t, int);
4949
50
5150#endif /* VECTREX_H_ */
src/mess/video/vectrex.c
r2386r2387
88#include "sound/dac.h"
99
1010
11#define RAMP_DELAY 6.333e-6
12#define SH_DELAY RAMP_DELAY
11#define ANALOG_DELAY 7800
12#define NVECT 10000
1313
14#define VEC_SHIFT 16
15#define INT_PER_CLOCK 600
16#define VECTREX_CLOCK 1500000
14#define INT_PER_CLOCK 550
1715
18#define PORTB 0
19#define PORTA 1
20
2116#ifndef M_SQRT1_2
2217#define M_SQRT1_2 0.70710678118654752440
2318#endif
2419
2520/*********************************************************************
26  Local variables
27 *********************************************************************/
21
22   Enums and typedefs
23
24*********************************************************************/
25
26enum {
27   PORTB = 0,
28   PORTA
29};
30
31enum {
32   A_X = 0,
33   A_ZR,
34   A_Z,
35   A_AUDIO,
36   A_Y,
37};
38
39typedef struct _vectrex_point
40{
41   int x; int y;
42   rgb_t col;
43   int intensity;
44} vectrex_point;
45
46
47/*********************************************************************
48
49   Prototypes
50
51*********************************************************************/
52
2853static WRITE8_HANDLER ( v_via_pa_w );
2954static WRITE8_HANDLER( v_via_pb_w );
3055static WRITE8_HANDLER ( v_via_ca2_w );
3156static WRITE8_HANDLER ( v_via_cb2_w );
3257
58
59/*********************************************************************
60
61   Local variables
62
63*********************************************************************/
64
3365static const struct via6522_interface vectrex_via6522_interface =
3466{
3567   v_via_pa_r, v_via_pb_r,         /* read PA/B */
r2386r2387
4072};
4173
4274static int x_center, y_center, x_max, y_max;
43static int x_int, y_int; /* X, Y integrators IC LF347*/
44static int lightpen_down=0, pen_x, pen_y; /* Lightpen position */
75static int x_int, y_int; /* X, Y integrators */
76static int lightpen_down, pen_x, pen_y; /* Lightpen position */
4577static emu_timer *lp_t;
46static int blank;
78static emu_timer *refresh;
79static UINT8 blank;
80static UINT8 ramp;
81static INT8 analog[5];
82static int vectrex_point_index;
83static int display_start, display_end;
84static vectrex_point vectrex_points[NVECT];
4785
48/* Analog signals: 0 : X-axis sample and hold IC LF347
49 *                 coupled by the MUX CD4052
50 *                 1 : Y-axis sample and hold IC LF347
51 *                 2 : "0" reference charge capacitor
52 *                 3 : Z-axis (brightness signal) sample and hold IC LF347
53 *                 4 : MPU sound resistive netowrk
54 */
86void (*vector_add_point_function) (int, int, rgb_t, int) = vectrex_add_point;
5587
56#define ASIG_Y 0
57#define ASIG_X 1
58#define ASIG_ZR 2
59#define ASIG_Z 3
60#define ASIG_MPU 4
6188
62#define NVECT 10000
89/*********************************************************************
6390
64static int analog_sig[5];
91 Lightpen
6592
66static double start_time;
67static int last_point_x, last_point_y, last_point_z, last_point=0;
68static double last_point_starttime;
69static float z_factor;
70static int vectrex_point_index = 0;
71static double vectrex_persistance = 0.05;
93*********************************************************************/
7294
73struct vectrex_point
95static TIMER_CALLBACK(lightpen_trigger)
7496{
75   int x; int y;
76   rgb_t col;
77   int intensity;
78   double time;
79};
80
81static struct vectrex_point vectrex_points[NVECT];
82void (*vector_add_point_function) (int, int, rgb_t, int) = vectrex_add_point;
83
84void vectrex_add_point (int x, int y, rgb_t color, int intensity)
85{
86   struct vectrex_point *newpoint;
87
88   vectrex_point_index = (vectrex_point_index+1) % NVECT;
89   newpoint = &vectrex_points[vectrex_point_index];
90
91   newpoint->x = x;
92   newpoint->y = y;
93   newpoint->col = color;
94   newpoint->intensity = intensity;
95   newpoint->time = attotime_to_double(timer_get_time());
96}
97
98/*********************************************************************
99  Lightpen
100 *********************************************************************/
101static void lightpen_trigger(running_machine *machine)
102{
10397   if (vectrex_lightpen_port & 1)
10498   {
105      via_0_ca1_w(machine, 0, 1);
106      via_0_ca1_w(machine, 0, 0);
99      via_set_input_ca1(0, 1);
100      via_set_input_ca1(0, 0);
107101   }
102
108103   if (vectrex_lightpen_port & 2)
109104   {
110105      cpunum_set_input_line(machine, 0, M6809_FIRQ_LINE, PULSE_LINE);
111106   }
112107}
113108
114static TIMER_CALLBACK(lightpen_trigger_callback)
115{
116   lightpen_trigger(machine);
117}
118
119109static int lightpen_check (void)
120110{
121   int dx,dy;
122   if (lightpen_down)
111   int dx, dy;
112   if (vectrex_lightpen_port != 0)
123113   {
124      dx=abs(pen_x-x_int);
125      dy=abs(pen_y-y_int);
126      if (dx<500000 && dy<500000)
127         return 1;
114      lightpen_down = readinputportbytag("LPENCONF") & 0x10;
115
116      if (lightpen_down)
117      {
118         pen_x = readinputportbytag("LPENX") * (x_max / 0xff);
119         pen_y = readinputportbytag("LPENY") * (y_max / 0xff);
120
121         dx = abs(pen_x - x_int);
122         dy = abs(pen_y - y_int);
123         if (dx < 500000 && dy < 500000)
124            return 1;
125      }
128126   }
127   else
128      lightpen_down = 0;
129
129130   return 0;
130131}
131132
132static void lightpen_show (running_machine *machine)
133{
134   int color;
133/*********************************************************************
135134
136   if (vectrex_lightpen_port != 0)
135   VIA T2 configuration
136
137   We need to snoop the frequency of VIA timer 2 here since most
138   vectrex games use that timer for steady screen refresh. Even if the
139   game stops T2 we continue refreshing the screen with the last known
140   frequency. Note that we quickly get out of sync in this case and the
141   screen will start flickering (see cut scenes in Spike).
142
143   Note that the timer can be adjusted to the full period each time T2
144   is restarted. This behaviour avoids flicker in most games. Some
145   games like mine 3d don't work well with this scheme though and show
146   severe jerking. So the second option is to leave the current period
147   alone (if the new period isn't shorter) and change only the next
148   full period.
149
150*********************************************************************/
151
152WRITE8_HANDLER(vectrex_via_w)
153{
154   static UINT16 counter;
155   attotime period;
156
157   switch (offset)
137158   {
138      if (input_port_read_indexed(machine, 6)&0x10)
139      {
140         lightpen_down=1;
141         color=0x00ff0000;
142      }
143      else
144      {
145         lightpen_down=0;
146         color=0x00ffffff;
147      }
159   case 8:
160      counter = (counter & 0xff00) | data;
161      break;
148162
149      pen_x = input_port_read_indexed(machine, 8)*(x_max/0xff);
150      pen_y = input_port_read_indexed(machine, 7)*(y_max/0xff);
163   case 9:
164      counter = (counter & 0x00ff) | (data << 8);
151165
152      vector_add_point(pen_x-250000,pen_y-250000,0,0xff);
153      vector_add_point(pen_x+250000,pen_y+250000,color,0xff);
154      vector_add_point(pen_x+250000,pen_y-250000,0,0xff);
155      vector_add_point(pen_x-250000,pen_y+250000,color,0xff);
166      period = attotime_mul(ATTOTIME_IN_HZ(cpunum_get_clock(0)), counter);
167
168      if (vectrex_reset_refresh)
169         timer_adjust_periodic(refresh, period, 0, period);
170      else
171         timer_adjust_periodic(refresh,
172                          attotime_min(period, timer_timeleft(refresh)),
173                          0,
174                          period);
175      break;
156176   }
157   else
158      lightpen_down=0;
177   via_write(0, offset, data);
159178}
160179
180
161181/*********************************************************************
162  Screen updating
163 *********************************************************************/
182
183   Screen refresh
184
185*********************************************************************/
186
187static TIMER_CALLBACK ( vectrex_refresh )
188{
189   /* Refresh only marks the range of vectors which will be drawn
190    * during the next VIDEO_UPDATE. */
191   display_start = display_end;
192   display_end = vectrex_point_index;
193}
194
164195VIDEO_UPDATE( vectrex )
165196{
166   int i, v;
167   double starttime;
197   int i;
168198
169199   vectrex_configuration();
170   lightpen_show(screen->machine);
171200
172   starttime = attotime_to_double(timer_get_time()) - vectrex_persistance;
173   if (starttime < 0) starttime = 0;
174   i = vectrex_point_index;
175
176   /* Find the oldest vector we want to display */
177   for (v=0; ((vectrex_points[i].time > starttime) && (v < NVECT)); v++)
178   {
179      i--;
180      if (i<0) i = NVECT - 1;
181   }
182
183201   /* start black */
184   vector_add_point(vectrex_points[i].x, vectrex_points[i].y, vectrex_points[i].col, 0);
202   vector_add_point(vectrex_points[display_start].x,
203                vectrex_points[display_start].y,
204                vectrex_points[display_start].col,
205                0);
185206
186   while (i != vectrex_point_index)
207   for (i = display_start; i != display_end; i = (i + 1) % NVECT)
187208   {
188      vector_add_point(vectrex_points[i].x,vectrex_points[i].y,vectrex_points[i].col, vectrex_points[i].intensity);
189      i = (i+1) % NVECT;
209      vector_add_point(vectrex_points[i].x,
210                   vectrex_points[i].y,
211                   vectrex_points[i].col,
212                   vectrex_points[i].intensity);
190213   }
191214
192215   VIDEO_UPDATE_CALL(vector);
r2386r2387
194217   return 0;
195218}
196219
220
197221/*********************************************************************
198  Vector functions
199 *********************************************************************/
222
223   Vector functions
224
225*********************************************************************/
226
227void vectrex_add_point (int x, int y, rgb_t color, int intensity)
228{
229   vectrex_point *newpoint;
230
231   vectrex_point_index = (vectrex_point_index+1) % NVECT;
232   newpoint = &vectrex_points[vectrex_point_index];
233
234   newpoint->x = x;
235   newpoint->y = y;
236   newpoint->col = color;
237   newpoint->intensity = intensity;
238}
239
200240void vectrex_add_point_stereo (int x, int y, rgb_t color, int intensity)
201241{
202242   if (vectrex_imager_status == 2) /* left = 1, right = 2 */
203      vectrex_add_point ((int)(y*M_SQRT1_2), (int)(((x_max-x)*M_SQRT1_2)+y_center), color, intensity);
243      vectrex_add_point ((int)(y * M_SQRT1_2)+ x_center,
244                     (int)(((x_max - x) * M_SQRT1_2)),
245                     color,
246                     intensity);
204247   else
205      vectrex_add_point ((int)(y*M_SQRT1_2), (int)((x_max-x)*M_SQRT1_2), color, intensity);
248      vectrex_add_point ((int)(y * M_SQRT1_2),
249                     (int)((x_max - x) * M_SQRT1_2),
250                     color,
251                     intensity);
206252}
207253
208INLINE void vectrex_zero_integrators(void)
254static TIMER_CALLBACK (vectrex_zero_integrators)
209255{
210   if (last_point)
211      vector_add_point_function (last_point_x, last_point_y, vectrex_beam_color,
212      MIN((int)(last_point_z*((attotime_to_double(timer_get_time())-last_point_starttime)*3E4)),255));
213   last_point = 0;
214
215   x_int=x_center+(analog_sig[ASIG_ZR]*INT_PER_CLOCK);
216   y_int=y_center+(analog_sig[ASIG_ZR]*INT_PER_CLOCK);
256   x_int = x_center + (analog[A_ZR] * INT_PER_CLOCK);
257   y_int = y_center + (analog[A_ZR] * INT_PER_CLOCK);
217258   vector_add_point_function (x_int, y_int, vectrex_beam_color, 0);
218259}
219260
220INLINE void vectrex_dot(void)
261static void update_vectors (void)
221262{
222   if (!last_point)
263   static attotime start_time;
264   int length;
265
266   if (!ramp)
223267   {
224      last_point_x = x_int;
225      last_point_y = y_int;
226      last_point_z = analog_sig[ASIG_Z] > 0? (int)(analog_sig[ASIG_Z] * z_factor): 0;
227      last_point_starttime = attotime_to_double(timer_get_time());
228      last_point = 1;
268      length = cpunum_get_clock(0) * INT_PER_CLOCK
269         * attotime_to_double(attotime_sub(timer_get_time(), start_time));
270
271      x_int += length * (analog[A_X] + analog[A_ZR]);
272      y_int += length * (analog[A_Y] + analog[A_ZR]);
273
274      vector_add_point_function(x_int, y_int, vectrex_beam_color, 2 * analog[A_Z] * blank);
229275   }
276   else
277   {
278      if (blank)
279         vector_add_point_function(x_int, y_int, vectrex_beam_color, 2 * analog[A_Z]);
280   }
281
282   start_time = timer_get_time();
230283}
231284
232INLINE void vectrex_solid_line(double int_time, int blank)
285
286/*********************************************************************
287
288   Delayed signals
289
290   The RAMP signal is delayed wrt. beam blanking. Getting this right
291   is important for text placement, the maze in Clean Sweep and many
292   other games.
293
294*********************************************************************/
295
296static TIMER_CALLBACK(update_signal)
233297{
234   int z = analog_sig[ASIG_Z] > 0? (int)(analog_sig[ASIG_Z]*z_factor): 0;
235    int length = (int)(VECTREX_CLOCK * INT_PER_CLOCK * int_time);
298   update_vectors();
236299
237   /* The BIOS draws lines as follows: First put a pattern in the VIA SR (this causes a dot). Then
238    * turn on RAMP and let the integrators do their job (this causes a line to be drawn).
239    * Obviously this first dot isn't needed so we optimize it away :) but we have to take care
240    * not to optimize _all_ dots, that's why we do draw the dot if the following line is
241    * black (a move). */
242   if (last_point && (!blank || !z))
243      vector_add_point_function(last_point_x, last_point_y, vectrex_beam_color,
244              MIN((int)(last_point_z*((attotime_to_double(timer_get_time())-last_point_starttime)*3E4)),255));
245   last_point = 0;
246
247   x_int += (int)(length * (analog_sig[ASIG_X] - analog_sig[ASIG_ZR]));
248   y_int += (int)(length * (analog_sig[ASIG_Y] + analog_sig[ASIG_ZR]));
249   vector_add_point_function(x_int, y_int, vectrex_beam_color, z * blank);
300   if (ptr)
301      * (UINT8 *) ptr = param;
250302}
251303
304
252305/*********************************************************************
253  Startup and stop
254 *********************************************************************/
306
307   Startup
308
309*********************************************************************/
310
255311VIDEO_START( vectrex )
256312{
257313   const device_config *screen = video_screen_first(machine->config);
258314   const rectangle *visarea = video_screen_get_visible_area(screen);
259315
260   x_center=((visarea->max_x
261        -visarea->min_x) / 2) << VEC_SHIFT;
262   y_center=((visarea->max_y
263        -visarea->min_y) / 2) << VEC_SHIFT;
264   x_max = visarea->max_x << VEC_SHIFT;
265   y_max = visarea->max_y << VEC_SHIFT;
316   x_center=((visarea->max_x - visarea->min_x) / 2) << 16;
317   y_center=((visarea->max_y - visarea->min_y) / 2) << 16;
318   x_max = visarea->max_x << 16;
319   y_max = visarea->max_y << 16;
266320
267321   via_config(0, &vectrex_via6522_interface);
268322   via_reset();
269   z_factor = 2;
270323
271324   imager_freq = 1;
272325
273   imager_timer = timer_alloc(vectrex_imager_right_eye, NULL);
274   timer_adjust_periodic(imager_timer, ATTOTIME_IN_HZ(imager_freq), 2, ATTOTIME_IN_HZ(imager_freq));
326   imager_timer = timer_alloc(vectrex_imager_eye, NULL);
327   timer_adjust_periodic(imager_timer,
328                    ATTOTIME_IN_HZ(imager_freq),
329                    2,
330                    ATTOTIME_IN_HZ(imager_freq));
275331
276   lp_t = timer_alloc(lightpen_trigger_callback, NULL);
332   lp_t = timer_alloc(lightpen_trigger, NULL);
277333
334   /* Switch off crosshairs since most games don't use lightpen */
335   crosshair_toggle(machine);
336
337   refresh = timer_alloc(vectrex_refresh, NULL);
338
278339   VIDEO_START_CALL(vector);
279340}
280341
281342
282343/*********************************************************************
283  VIA interface functions
284 *********************************************************************/
285INLINE void vectrex_multiplexer (int mux)
344
345   VIA interface functions
346
347*********************************************************************/
348
349static void vectrex_multiplexer (int mux)
286350{
287   analog_sig[mux + 1]=(signed char)vectrex_via_out[PORTA];
288   if (mux == 3)
289      DAC_data_w(0,(signed char)vectrex_via_out[PORTA]+0x80);
351   timer_set(ATTOTIME_IN_NSEC(ANALOG_DELAY), &analog[mux], vectrex_via_out[PORTA], update_signal);
352
353   if (mux == A_AUDIO)
354      DAC_data_w(0, vectrex_via_out[PORTA]);
290355}
291356
292357static WRITE8_HANDLER ( v_via_pb_w )
r2386r2387
294359   if (!(data & 0x80))
295360   {
296361      /* RAMP is active */
297      if ((vectrex_via_out[PORTB] & 0x80))
362      if ((ramp & 0x80))
298363      {
299364         /* RAMP was inactive before */
300         start_time = attotime_to_double(timer_get_time())+RAMP_DELAY;
301365
302366         if (lightpen_down)
303367         {
304368            /* Simple lin. algebra to check if pen is near
305             * the line defined by (ASIG_X,ASIG_Y).
369             * the line defined by (A_X,A_Y).
306370             * If that is the case, set a timer which goes
307371             * off when the beam reaches the pen. Exact
308372             * timing is important here.
r2386r2387
320384             *            a
321385             */
322386            double a2, b2, ab, d2;
323            ab = (double)(pen_x-x_int)*analog_sig[ASIG_X]
324               +(double)(pen_y-y_int)*analog_sig[ASIG_Y];
325            if (ab>0)
387            ab = (pen_x - x_int) * analog[A_X]
388               +(pen_y - y_int) * analog[A_Y];
389            if (ab > 0)
326390            {
327               a2 = (analog_sig[ASIG_X]*analog_sig[ASIG_X]
328                    +analog_sig[ASIG_Y]*analog_sig[ASIG_Y]);
329               b2 = (double)(pen_x-x_int)*(pen_x-x_int)
330                  +(double)(pen_y-y_int)*(pen_y-y_int);
331               d2=b2-ab*ab/a2;
332               if (d2<2e10 && analog_sig[ASIG_Z]*blank>0)
333                  timer_adjust_oneshot(lp_t, double_to_attotime(ab/a2/(VECTREX_CLOCK*INT_PER_CLOCK)), 0);
391               a2 = (double)(analog[A_X] * analog[A_X]
392                          +(double)analog[A_Y] * analog[A_Y]);
393               b2 = (double)(pen_x - x_int) * (pen_x - x_int)
394                  +(double)(pen_y - y_int) * (pen_y - y_int);
395               d2 = b2 - ab * ab / a2;
396               if (d2 < 2e10 && analog[A_Z] * blank > 0)
397                  timer_adjust_oneshot(lp_t, double_to_attotime(ab / a2 / (cpunum_get_clock(0) * INT_PER_CLOCK)), 0);
334398            }
335399         }
336400      }
337401
338402      if (!(data & 0x1) && (vectrex_via_out[PORTB] & 0x1))
403      {
339404         /* MUX has been enabled */
340         /* This is a rare case used by some new games */
341      {
342         double time_now = attotime_to_double(timer_get_time())+SH_DELAY;
343         vectrex_solid_line(time_now-start_time, blank);
344         start_time = time_now;
405         timer_set(ATTOTIME_IN_NSEC(ANALOG_DELAY), NULL, 0, update_signal);
345406      }
346407   }
347408   else
348409   {
349410      /* RAMP is inactive */
350      if (!(vectrex_via_out[PORTB] & 0x80))
411      if (!(ramp & 0x80))
351412      {
352         /* RAMP was active before - we can draw the line */
353         vectrex_solid_line(attotime_to_double(timer_get_time())-start_time+RAMP_DELAY, blank);
354413         /* Cancel running timer, line already finished */
355414         if (lightpen_down)
356415            timer_adjust_oneshot(lp_t, attotime_never, 0);
r2386r2387
360419   /* Sound */
361420   if (data & 0x10)
362421   {
363      /* BDIR active, PSG latches */
364422      if (data & 0x08) /* BC1 (do we select a reg or write it ?) */
365423         AY8910_control_port_0_w(machine, 0, vectrex_via_out[PORTA]);
366424      else
r2386r2387
368426   }
369427
370428   if (!(data & 0x1) && (vectrex_via_out[PORTB] & 0x1))
371      /* MUX has been enabled, so check with which signal the MUX
372       * coulpes the DAC output.  */
373429      vectrex_multiplexer ((data >> 1) & 0x3);
374430
375431   vectrex_via_out[PORTB] = data;
432   timer_set(ATTOTIME_IN_NSEC(ANALOG_DELAY), &ramp, data & 0x80, update_signal);
376433}
377434
378435static WRITE8_HANDLER ( v_via_pa_w )
379436{
380   double time_now;
437   /* DAC output always goes to Y integrator */
438   vectrex_via_out[PORTA] = data;
439   timer_set(ATTOTIME_IN_NSEC(ANALOG_DELAY), &analog[A_Y], data, update_signal);
381440
382   if (!(vectrex_via_out[PORTB] & 0x80))  /* RAMP active (low) ? */
383   {
384      /* The game changes the sample and hold ICs (X/Y axis)
385       * during line draw (curved vectors)
386       * Draw the vector with the current settings
387       * before updating the signals.
388       */
389      time_now = attotime_to_double(timer_get_time()) + SH_DELAY;
390      vectrex_solid_line(time_now - start_time, blank);
391      start_time = time_now;
392   }
393   /* DAC output always goes into Y integrator */
394   vectrex_via_out[PORTA] = analog_sig[ASIG_Y] = (signed char)data;
395
396441   if (!(vectrex_via_out[PORTB] & 0x1))
397      /* MUX is enabled, so check with which signal the MUX
398       * coulpes the DAC output.  */
399442      vectrex_multiplexer ((vectrex_via_out[PORTB] >> 1) & 0x3);
400443}
401444
402445static WRITE8_HANDLER ( v_via_ca2_w )
403446{
404   if  (!data)    /* ~ZERO low ? Then zero integrators*/
405      vectrex_zero_integrators();
447   if (!data)
448      timer_set(ATTOTIME_IN_NSEC(ANALOG_DELAY), NULL, 0, vectrex_zero_integrators);
406449}
407450
408451static WRITE8_HANDLER ( v_via_cb2_w )
409452{
410   double time_now;
411   if (blank != data)
453   static UINT8 cb2 = 0;
454
455   if (cb2 != data)
412456   {
413      if (vectrex_via_out[PORTB] & 0x80)
414      {
415         /* RAMP inactive */
416         /* This generates a dot (here we take the dwell time into account) */
417
418         if (data)
419            vectrex_dot();
420      }
421      else
422      {
423         /* RAMP active
424          * Take MAX because RAMP is slower than BLANK
425          */
426         time_now = MAX(attotime_to_double(timer_get_time()),start_time);
427         vectrex_solid_line(time_now - start_time, blank);
428         start_time = time_now;
429      }
430457      if (data & lightpen_check())
431         lightpen_trigger(machine);
458         timer_set(attotime_zero, NULL, 0, lightpen_trigger);
432459
433      blank = data;
460      timer_set(attotime_zero, &blank, data, update_signal);
461      cb2 = data;
434462   }
435463}
436464
465
437466/*****************************************************************
438467
439  RA+A Spectrum I+
468  RA+A Spectrum I+
440469
441470*****************************************************************/
442471
r2386r2387
450479WRITE8_HANDLER( raaspec_led_w )
451480{
452481   logerror("Spectrum I+ LED: %i%i%i%i%i%i%i%i\n",
453             (data>>7)&0x1, (data>>6)&0x1, (data>>5)&0x1, (data>>4)&0x1,
454             (data>>3)&0x1, (data>>2)&0x1, (data>>1)&0x1, data&0x1);
482          (data>>7)&0x1, (data>>6)&0x1, (data>>5)&0x1, (data>>4)&0x1,
483          (data>>3)&0x1, (data>>2)&0x1, (data>>1)&0x1, data&0x1);
455484}
456485
457486VIDEO_START( raaspec )
r2386r2387
459488   const device_config *screen = video_screen_first(machine->config);
460489   const rectangle *visarea = video_screen_get_visible_area(screen);
461490
462   x_center=((visarea->max_x
463        -visarea->min_x)/2) << VEC_SHIFT;
464   y_center=((visarea->max_y
465        -visarea->min_y)/2) << VEC_SHIFT;
466   x_max = visarea->max_x << VEC_SHIFT;
467   y_max = visarea->max_y << VEC_SHIFT;
491   x_center=((visarea->max_x - visarea->min_x) / 2) << 16;
492   y_center=((visarea->max_y - visarea->min_y) / 2) << 16;
493   x_max = visarea->max_x << 16;
494   y_max = visarea->max_y << 16;
468495
469496   via_config(0, &spectrum1_via6522_interface);
470497   via_reset();
471   z_factor = 2;
498   refresh = timer_alloc(vectrex_refresh, NULL);
472499
473500   raaspec_led_w(machine, 0, 0xff);
474501
src/mess/machine/vectrex.c
r2386r2387
1717#define PORTB 0
1818#define PORTA 1
1919
20
2021/*********************************************************************
21  Global variables
22 *********************************************************************/
22
23   Global variables
24
25*********************************************************************/
26
2327unsigned char vectrex_via_out[2];
24rgb_t vectrex_beam_color = RGB_WHITE;      /* the color of the vectrex beam */
25int vectrex_imager_status = 0;      /* 0 = off, 1 = right eye, 2 = left eye */
28rgb_t vectrex_beam_color = RGB_WHITE;      /* the color of the vectrex beam */
29int vectrex_imager_status = 0;     /* 0 = off, 1 = right eye, 2 = left eye */
2630double imager_freq;
2731emu_timer *imager_timer;
2832int vectrex_lightpen_port=0;
29UINT8 *vectrex_ram_base;
30size_t vectrex_ram_size;
33int vectrex_reset_refresh;
3134
35
3236/*********************************************************************
33  Local variables
34 *********************************************************************/
3537
38   Local variables
39
40*********************************************************************/
41
3642/* Colors for right and left eye */
3743static rgb_t imager_colors[6] =
3844{
r2386r2387
4147
4248/* Starting points of the three colors */
4349/* Values taken from J. Nelson's drawings*/
44//static const double narrow_escape_angles[3] = {0,0.15277778, 0.34444444};
45//static const double minestorm_3d_angles[3] = {0,0.16111111, 0.18888888};
46//static const double crazy_coaster_angles[3] = {0,0.15277778, 0.34444444};
4750
48static const double minestorm_3d_angles[3] = {0,0.1692, 0.2086};
49static const double narrow_escape_angles[3] = {0,0.1631, 0.3305};
50static const double crazy_coaster_angles[3] = {0,0.1631, 0.3305};
51static const double minestorm_3d_angles[3] = {0, 0.1692, 0.2086};
52static const double narrow_escape_angles[3] = {0, 0.1631, 0.3305};
53static const double crazy_coaster_angles[3] = {0, 0.1631, 0.3305};
5154
5255
5356static const double unknown_game_angles[3] = {0,0.16666666, 0.33333333};
5457static const double *vectrex_imager_angles = unknown_game_angles;
55static unsigned char vectrex_imager_pinlevel=0x00;
58static unsigned char vectrex_imager_pinlevel;
5659
5760static int vectrex_verify_cart (char *data)
5861{
r2386r2387
6366      return IMAGE_VERIFY_FAIL;
6467}
6568
69
6670/*********************************************************************
67  ROM load and id functions
68 *********************************************************************/
71
72   ROM load and id functions
73
74*********************************************************************/
75
6976DEVICE_IMAGE_LOAD( vectrex_cart )
7077{
7178   image_fread(image, memory_region(REGION_CPU1), 0x8000);
r2386r2387
7784      return INIT_FAIL;
7885   }
7986
87   /* If VIA T2 starts, reset refresh timer.
88      This is the best strategy for most games. */
89   vectrex_reset_refresh = 1;
90
8091   vectrex_imager_angles = narrow_escape_angles;
8192
8293   /* let's do this 3D detection with a strcmp using data inside the cart images */
r2386r2387
96107   if (!memcmp(memory_region(REGION_CPU1)+0x11,"3D MINE STORM",13))
97108   {
98109      vectrex_imager_angles = minestorm_3d_angles;
110
111      /* Don't reset T2 each time it's written.
112         This would cause jerking in mine3. */
113      vectrex_reset_refresh = 0;
99114   }
100115
101116   return INIT_PASS;
102117}
103118
119
104120/*********************************************************************
105  Vectrex configuration (mainly 3D Imager)
106 *********************************************************************/
121
122   Vectrex configuration (mainly 3D Imager)
123
124*********************************************************************/
125
107126void vectrex_configuration(void)
108127{
109   unsigned char cport = input_port_read_indexed(Machine, 5);
128   unsigned char cport = readinputportbytag("3DCONF");
110129
111130   /* Vectrex 'dipswitch' configuration */
112131
r2386r2387
183202      vectrex_beam_color = RGB_WHITE;
184203      imager_colors[0]=imager_colors[1]=imager_colors[2]=imager_colors[3]=imager_colors[4]=imager_colors[5]=RGB_WHITE;
185204   }
186   vectrex_lightpen_port = (input_port_read_indexed(Machine, 6) & 0x03);
205   vectrex_lightpen_port = readinputportbytag("LPENCONF") & 0x03;
187206}
188207
189208/*********************************************************************
190  VIA interface functions
191 *********************************************************************/
209
210   VIA interface functions
211
212*********************************************************************/
213
192214void v_via_irq (int level)
193215{
194216   cpunum_set_input_line(Machine, 0, M6809_IRQ_LINE, level);
r2386r2387
197219READ8_HANDLER( v_via_pb_r )
198220{
199221   int pot;
200   pot = input_port_read_indexed(machine, ((vectrex_via_out[PORTB] & 0x6)>>1) + 1) - 0x80;
222   pot = readinputport(((vectrex_via_out[PORTB] & 0x6) >> 1)) - 0x80;
201223
202224   if (pot > (signed char)vectrex_via_out[PORTA])
203225      vectrex_via_out[PORTB] |= 0x20;
r2386r2387
214236   {
215237      vectrex_via_out[PORTA] = AY8910_read_port_0_r(machine, 0)
216238         & ~(vectrex_imager_pinlevel & 0x80);
217      vectrex_imager_pinlevel &= ~0x80;
218239   }
219240   return vectrex_via_out[PORTA];
220241}
221242
222243READ8_HANDLER( s1_via_pb_r )
223244{
224   return (vectrex_via_out[PORTB] & ~0x40) | ((input_port_read_indexed(machine, 1) & 0x1)<<6);
245   return (vectrex_via_out[PORTB] & ~0x40) | (readinputportbytag("COIN") & 0x40);
225246}
226247
248
227249/*********************************************************************
228  3D Imager support
229 *********************************************************************/
250
251   3D Imager support
252
253*********************************************************************/
254
230255static TIMER_CALLBACK(vectrex_imager_change_color)
231256{
232257   vectrex_beam_color = param;
233258}
234259
235TIMER_CALLBACK(vectrex_imager_right_eye)
260static TIMER_CALLBACK(update_level)
236261{
262   if (ptr)
263      * (UINT8 *) ptr = param;
264}
265
266TIMER_CALLBACK(vectrex_imager_eye)
267{
237268   int coffset;
238   double rtime = (1.0/imager_freq);
269   double rtime = (1.0 / imager_freq);
239270
240271   if (vectrex_imager_status > 0)
241272   {
242273      vectrex_imager_status = param;
243      coffset = param>1?3:0;
274      coffset = param > 1? 3: 0;
244275      timer_set (double_to_attotime(rtime * vectrex_imager_angles[0]), NULL, imager_colors[coffset+2], vectrex_imager_change_color);
245276      timer_set (double_to_attotime(rtime * vectrex_imager_angles[1]), NULL, imager_colors[coffset+1], vectrex_imager_change_color);
246277      timer_set (double_to_attotime(rtime * vectrex_imager_angles[2]), NULL, imager_colors[coffset], vectrex_imager_change_color);
247278
248279      if (param == 2)
249280      {
250         timer_set (double_to_attotime(rtime * 0.50), NULL, 1, vectrex_imager_right_eye);
281         timer_set (double_to_attotime(rtime * 0.50), NULL, 1, vectrex_imager_eye);
251282
252283         /* Index hole sensor is connected to IO7 which triggers also CA1 of VIA */
253         via_0_ca1_w(machine, 0, 1);
254         via_0_ca1_w(machine, 0, 0);
284         via_set_input_ca1(0, 1);
285         via_set_input_ca1(0, 0);
255286         vectrex_imager_pinlevel |= 0x80;
287         timer_set (double_to_attotime(rtime / 360.0), &vectrex_imager_pinlevel, 0, update_level);
256288      }
257289   }
258290}
r2386r2387
278310
279311      if (wavel < 1)
280312      {
281         /* The Vectrex sends a stream of pulses which controls the speed of
313         /* The Vectrex sends a stream of pulses which control the speed of
282314            the motor using Pulse Width Modulation. Guessed parameters are MMI
283315            (mass moment of inertia) of the color wheel, DAMPC (damping coefficient)
284316            of the whole thing and some constants of the motor's torque/speed curve.
285317            pwl is the negative pulse width and wavel is the whole wavelength. */
286318
287319         ang_acc = (50.0 - 1.55 * imager_freq) / MMI;
288         imager_freq += ang_acc * pwl + DAMPC*imager_freq/MMI * wavel;
320         imager_freq += ang_acc * pwl + DAMPC * imager_freq / MMI * wavel;
289321
290322         if (imager_freq > 1)
291323         {
292324            timer_adjust_periodic(imager_timer,
293               double_to_attotime(MIN(1.0/imager_freq, attotime_to_double(timer_timeleft(imager_timer)))),
294               2,
295               ATTOTIME_IN_HZ(imager_freq));
325                             double_to_attotime(MIN(1.0 / imager_freq, attotime_to_double(timer_timeleft(imager_timer)))),
326                             2,
327                             double_to_attotime(1.0 / imager_freq));
296328         }
297329      }
298330   }
r2386r2387
305337
306338DRIVER_INIT( vectrex )
307339{
308   int i;
309
310   /* Set the whole cart ROM area to 1. This is needed to work around a bug (?)
311    * in Minestorm where the exec-rom attempts to access a vector list here.
312    * 1 signals the end of the vector list.
340   /*
341    * Uninitialized RAM needs to return 0xff. Otherwise the mines in
342    * the first level of Minestorm are not evenly distributed.
313343    */
314   if (vectrex_verify_cart((char*)memory_region(REGION_CPU1)) == IMAGE_VERIFY_FAIL)
315   {
316      memset (memory_region(REGION_CPU1), 1, 0x8000);
317   }
318344
319   for (i = 0; i < vectrex_ram_size; i++)
320      vectrex_ram_base[i] = mame_rand(machine);
345   memset(vectorram, 0xff, vectorram_size);
321346}
src/mess/drivers/vectrex.c
r2386r2387
1717
1818static ADDRESS_MAP_START( vectrex_map , ADDRESS_SPACE_PROGRAM, 8)
1919   AM_RANGE( 0x0000, 0x7fff) AM_ROM
20   AM_RANGE( 0xc800, 0xcbff) AM_RAM AM_MIRROR( 0x0400 ) AM_BASE(&vectrex_ram_base) AM_SIZE(&vectrex_ram_size)
21   AM_RANGE( 0xd000, 0xd7ff) AM_READWRITE( via_0_r, via_0_w )
20   AM_RANGE( 0xc800, 0xcbff) AM_RAM AM_MIRROR( 0x0400 ) AM_BASE(&vectorram) AM_SIZE(&vectorram_size)
21   AM_RANGE( 0xd000, 0xd7ff) AM_READWRITE( via_0_r, vectrex_via_w )
2222   AM_RANGE( 0xe000, 0xffff) AM_ROM
2323ADDRESS_MAP_END
2424
2525static INPUT_PORTS_START( vectrex )
26   PORT_START
26   PORT_START_TAG("CONTR1X")
27   PORT_BIT( 0xff, 0x80, IPT_AD_STICK_X ) PORT_MINMAX(0,0xff) PORT_SENSITIVITY(50) PORT_KEYDELTA(30)
28
29   PORT_START_TAG("CONTR1Y")
30   PORT_BIT( 0xff, 0x80, IPT_AD_STICK_Y ) PORT_MINMAX(0,0xff) PORT_SENSITIVITY(50) PORT_KEYDELTA(30) PORT_REVERSE
31
32   PORT_START_TAG("CONTR2X")
33   PORT_BIT( 0xff, 0x80, IPT_AD_STICK_X ) PORT_MINMAX(0,0xff) PORT_SENSITIVITY(50) PORT_KEYDELTA(30) PORT_PLAYER(2)
34
35   PORT_START_TAG("CONTR2Y")
36   PORT_BIT( 0xff, 0x80, IPT_AD_STICK_Y ) PORT_MINMAX(0,0xff) PORT_SENSITIVITY(50) PORT_KEYDELTA(30) PORT_REVERSE PORT_PLAYER(2)
37
38   PORT_START_TAG("BUTTONS")
2739   PORT_BIT( 0x01, IP_ACTIVE_LOW, IPT_BUTTON1) PORT_PLAYER(1)
2840   PORT_BIT( 0x02, IP_ACTIVE_LOW, IPT_BUTTON2) PORT_PLAYER(1)
2941   PORT_BIT( 0x04, IP_ACTIVE_LOW, IPT_BUTTON3) PORT_PLAYER(1)
r2386r2387
3345   PORT_BIT( 0x40, IP_ACTIVE_LOW, IPT_BUTTON3) PORT_PLAYER(2)
3446   PORT_BIT( 0x80, IP_ACTIVE_LOW, IPT_BUTTON4) PORT_PLAYER(2)
3547
36   PORT_START   /* IN1 */
37   PORT_BIT( 0xff, 0x80, IPT_AD_STICK_X ) PORT_MINMAX(0,255) PORT_SENSITIVITY(50) PORT_KEYDELTA(30)
38
39   PORT_START   /* IN2 */
40   PORT_BIT( 0xff, 0x80, IPT_AD_STICK_Y ) PORT_MINMAX(0,255) PORT_SENSITIVITY(50) PORT_KEYDELTA(30) PORT_REVERSE
41
42   PORT_START   /* IN3 */
43   PORT_BIT( 0xff, 0x80, IPT_AD_STICK_X ) PORT_MINMAX(0,255) PORT_SENSITIVITY(50) PORT_KEYDELTA(30) PORT_PLAYER(2)
44
45   PORT_START   /* IN4 */
46   PORT_BIT( 0xff, 0x80, IPT_AD_STICK_Y ) PORT_MINMAX(0,255) PORT_SENSITIVITY(50) PORT_KEYDELTA(30) PORT_REVERSE PORT_PLAYER(2)
47
48   PORT_START /* IN5 */
48   PORT_START_TAG("3DCONF")
4949   PORT_DIPNAME( 0x01, 0x00, "3D Imager")
5050   PORT_DIPSETTING(0x00, DEF_STR ( Off ))
5151   PORT_DIPSETTING(0x01, DEF_STR ( On ))
r2386r2387
6565   PORT_DIPSETTING(0x60, "Blue")
6666   PORT_DIPSETTING(0x80, "Color")
6767
68   PORT_START /* IN6 */
68   PORT_START_TAG("LPENCONF")
6969   PORT_DIPNAME( 0x03, 0x00, "Lightpen")
7070   PORT_DIPSETTING(0x00, DEF_STR ( Off ))
7171   PORT_DIPSETTING(0x01, "left port")
7272   PORT_DIPSETTING(0x02, "right port")
7373   PORT_BIT( 0x10, IP_ACTIVE_HIGH, IPT_BUTTON5) PORT_CODE(MOUSECODE_BUTTON1)
7474
75    PORT_START /* Lightpen - X AXIS */
76    PORT_BIT( 0xff, 0x80, IPT_LIGHTGUN_X ) PORT_MINMAX(0,0xff) PORT_SENSITIVITY(35) PORT_KEYDELTA(1) PORT_PLAYER(1)
75   PORT_START_TAG("LPENY")
76   PORT_BIT( 0xff, 0x80, IPT_LIGHTGUN_X )  PORT_CROSSHAIR(Y, 1, 0, 0) PORT_MINMAX(0,0xff) PORT_SENSITIVITY(35) PORT_KEYDELTA(1) PORT_PLAYER(1)
7777
78    PORT_START /* Lightpen - Y AXIS */
79    PORT_BIT( 0xff, 0x80, IPT_LIGHTGUN_Y ) PORT_MINMAX(0,0xff) PORT_SENSITIVITY(35) PORT_KEYDELTA(1) PORT_PLAYER(1)
78   PORT_START_TAG("LPENX")
79   PORT_BIT( 0xff, 0x80, IPT_LIGHTGUN_Y )  PORT_CROSSHAIR(X, 1, 0, 0) PORT_MINMAX(0,0xff) PORT_SENSITIVITY(35) PORT_KEYDELTA(1) PORT_REVERSE PORT_PLAYER(1)
8080
81
8281INPUT_PORTS_END
8382
8483
8584
8685static const struct AY8910interface ay8910_interface =
8786{
88   input_port_0_r,
87   input_port_4_r,
8988   0,
9089   vectrex_psg_port_w,
9190   0
r2386r2387
9493
9594static MACHINE_DRIVER_START( vectrex )
9695   /* basic machine hardware */
97   MDRV_CPU_ADD_TAG("main", M6809, 1500000)        /* 1.5 Mhz */
96   MDRV_CPU_ADD_TAG("main", M6809, XTAL_6MHz/4)
9897   MDRV_CPU_PROGRAM_MAP(vectrex_map, 0)
9998
10099   MDRV_SCREEN_ADD("main", VECTOR)
101100   MDRV_SCREEN_REFRESH_RATE(60)
102101
103    /* video hardware */
102   /* video hardware */
104103   MDRV_SCREEN_FORMAT(BITMAP_FORMAT_RGB32)
105104   MDRV_SCREEN_SIZE(400, 300)
106105   MDRV_SCREEN_VISIBLE_AREA(0, 399, 0, 299)
107   MDRV_PALETTE_LENGTH(256 + 32768)
108   /*MDRV_ASPECT_RATIO(3, 4)*/
109106
110107   MDRV_VIDEO_START( vectrex )
111108   MDRV_VIDEO_UPDATE( vectrex )
r2386r2387
125122   switch(state)
126123   {
127124      /* --- the following bits of info are returned as 64-bit signed integers --- */
128      case MESS_DEVINFO_INT_COUNT:                     info->i = 1; break;
125      case MESS_DEVINFO_INT_COUNT:                            info->i = 1; break;
129126
130127      /* --- the following bits of info are returned as pointers to data or functions --- */
131      case MESS_DEVINFO_PTR_LOAD:                     info->load = DEVICE_IMAGE_LOAD_NAME(vectrex_cart); break;
128      case MESS_DEVINFO_PTR_LOAD:                         info->load = DEVICE_IMAGE_LOAD_NAME(vectrex_cart); break;
132129
133130      /* --- the following bits of info are returned as NULL-terminated strings --- */
134      case MESS_DEVINFO_STR_FILE_EXTENSIONS:            strcpy(info->s = device_temp_str(), "bin,gam,vec"); break;
131      case MESS_DEVINFO_STR_FILE_EXTENSIONS:              strcpy(info->s = device_temp_str(), "bin,gam,vec"); break;
135132
136      default:                              cartslot_device_getinfo(devclass, state, info); break;
133      default:                                        cartslot_device_getinfo(devclass, state, info); break;
137134   }
138135}
139136
r2386r2387
142139SYSTEM_CONFIG_END
143140
144141ROM_START(vectrex)
145    ROM_REGION(0x10000,REGION_CPU1, 0)
146    ROM_LOAD("system.img", 0xe000, 0x2000, CRC(ba13fb57) SHA1(65d07426b520ddd3115d40f255511e0fd2e20ae7))
142   ROM_REGION(0x10000,REGION_CPU1, 0)
143   ROM_LOAD("system.img", 0xe000, 0x2000, CRC(ba13fb57) SHA1(65d07426b520ddd3115d40f255511e0fd2e20ae7))
147144ROM_END
148145
149146
r2386r2387
186183   AM_RANGE( 0x0000, 0x7fff) AM_ROM
187184   AM_RANGE( 0x8000, 0x87ff) AM_RAM AM_BASE(&generic_nvram) AM_SIZE(&generic_nvram_size)
188185   AM_RANGE( 0xa000, 0xa000) AM_WRITE( raaspec_led_w )
189   AM_RANGE( 0xc800, 0xcbff) AM_RAM AM_RAM AM_MIRROR( 0x0400 )
190   AM_RANGE( 0xd000, 0xd7ff) AM_READWRITE ( via_0_r,  via_0_w)
186   AM_RANGE( 0xc800, 0xcbff) AM_RAM AM_MIRROR( 0x0400 ) AM_BASE(&vectorram) AM_SIZE(&vectorram_size)
187   AM_RANGE( 0xd000, 0xd7ff) AM_READWRITE ( via_0_r,  vectrex_via_w)
191188   AM_RANGE( 0xe000, 0xffff) AM_ROM
192189ADDRESS_MAP_END
193190
194191static INPUT_PORTS_START( raaspec )
195   PORT_START
196    PORT_BIT( 0x01, IP_ACTIVE_LOW, IPT_BUTTON1 )
192   PORT_START_TAG("LPENCONF")
193   PORT_START_TAG("LPENY")
194   PORT_START_TAG("LPENX")
195   PORT_START_TAG("3DCONF")
196   PORT_START_TAG("BUTTONS")
197   PORT_BIT( 0x01, IP_ACTIVE_LOW, IPT_BUTTON1 )
197198   PORT_BIT( 0x02, IP_ACTIVE_LOW, IPT_BUTTON2 )
198199   PORT_BIT( 0x04, IP_ACTIVE_LOW, IPT_BUTTON3 )
199200   PORT_BIT( 0x08, IP_ACTIVE_LOW, IPT_BUTTON4 )
r2386r2387
201202   PORT_BIT( 0x20, IP_ACTIVE_LOW, IPT_BUTTON6 )
202203   PORT_BIT( 0x40, IP_ACTIVE_LOW, IPT_BUTTON7 )
203204   PORT_BIT( 0x80, IP_ACTIVE_LOW, IPT_BUTTON8 )
204
205   PORT_START
206    PORT_BIT( 0x01, IP_ACTIVE_HIGH, IPT_SELECT )
207
205   PORT_START_TAG("COIN")
206   PORT_BIT( 0x40, IP_ACTIVE_HIGH, IPT_COIN1 )
208207INPUT_PORTS_END
209208
210209
r2386r2387
214213   MDRV_CPU_PROGRAM_MAP( raaspec_map, 0 )
215214   MDRV_NVRAM_HANDLER(generic_0fill)
216215
217   MDRV_PALETTE_LENGTH(254)
218
219216   MDRV_VIDEO_START( raaspec )
220217MACHINE_DRIVER_END
221218
r2386r2387
232229***************************************************************************/
233230
234231/*    YEAR  NAME      PARENT    COMPAT  MACHINE   INPUT     INIT        CONFIG      COMPANY FULLNAME */
235CONS( 1982, vectrex,  0,       0,      vectrex,  vectrex,   vectrex,   vectrex,   "General Consumer Electronics",   "Vectrex" , ROT270)
236CONS( 1984, raaspec,  vectrex,   0,      raaspec,  raaspec,   0,         NULL,      "Roy Abel & Associates",   "Spectrum I+" , ROT270)
232CONS( 1982, vectrex,  0,        0,      vectrex,  vectrex,  vectrex,    vectrex,    "General Consumer Electronics",   "Vectrex" , ROT270)
233CONS( 1984, raaspec,  vectrex,  0,      raaspec,  raaspec,  vectrex,    NULL,       "Roy Abel & Associates",   "Spectrum I+" , ROT270)

Previous 15994 Revisions Next


© 1998-2018 The MESS Team