# This is a shell archive.  Save it in a file, remove anything before
# this line, and then unpack it by entering "sh file".  Note, it may
# create directories; files and directories will be owned by you and
# have default permissions.
#
# This archive contains:
#
# Makefile
# tetris.c
# drawing.c
# motion.c
# tetris.h
#
echo x - Makefile
sed 's/^X//' >Makefile << 'END-of-Makefile'
X#
X# Copyright (C) 1993 Fariborz ``Skip'' Tavakkolian
X#
X# $Id: Makefile,v 1.4 93/06/13 12:27:30 fst Exp $
X#
X# Description:
X#
X# $Log: Makefile,v $
X# Revision 1.4  93/06/13  12:27:30  fst
X# Added the lint stuff
X# 
X# Revision 1.3  93/06/06  11:05:53  fst
X# Changed CFLAGS to -g for debugging by dmdpi
X# 
X# Revision 1.2  93/06/05  22:10:42  fst
X# Changed the RCS ``Header'' with ``Id''.
X# 
X# Revision 1.1  93/06/05  22:03:05  fst
X# Initial revision
X# 
X
XSOURCES = tetris.c drawing.c motion.c
XOBJECTS = $(SOURCES:.c=.o)
X
XTARGET = tetris.m
XTARGET_LINT = tetris.lint
XCC=dmdcc
XCFLAGS=-g
X
X$(TARGET_LINT): $(SOURCES)
X lint -I$(DMD)/include $(SOURCES)
X
X$(TARGET): $(OBJECTS)
X $(CC) -o $(TARGET) $(OBJECTS)
X
Xdmdtet.shar:
X shar Makefile $(SOURCES) tetris.h > dmdtet.shar
X
Xtetris.o: tetris.h
Xmotion.o: tetris.h
END-of-Makefile
echo x - tetris.c
sed 's/^X//' >tetris.c << 'END-of-tetris.c'
X/**********************************************************/
X/*                                                        */
X/* Copyright (C) 1993 Fariborz ``Skip'' Tavakkolian       */
X/*                                                        */
X/**********************************************************/
X
Xstatic char *RCSid = "$Id: tetris.c,v 1.4 93/06/13 12:28:25 fst Exp $";
X
X/*
X * Description:
X *
X * $Log: tetris.c,v $
X * Revision 1.4  93/06/13  12:28:25  fst
X * Added casts to satisfy link.
X * 
X * Revision 1.3  93/06/06  11:07:13  fst
X * Added the current game piece to the arguments passed to Collapse_Full_Rows
X * to allow for checking of only those rows which are effected by the last
X * move.
X * 
X * Revision 1.2  93/06/05  22:11:16  fst
X * Changed the RCS ``Header'' with ``Id''.
X * 
X * Revision 1.1  93/06/05  22:03:58  fst
X * Initial revision
X * 
X */
X
X#include <dmd.h>
X#include <dmdio.h>
X#include <object.h>
X#include <font.h>
X#include "tetris.h"
X
X/* Library Routines and associated manual page. */
Xvoid bitblt();
Xvoid lprintf();
Xvoid sleep();
XPoint sPtCurrent();
Xint wait();
X
X
X/* tetris functions */
Xextern char *Gen_Menu_Items();
X
X/* local variables */
Xstatic int running = 0;
Xstatic int new_piece = 1;
Xstatic int fall_speed = FALL_SPEED;
Xstatic int p_count = 0;
Xstatic int score = 0;
X
X#define ADJUST_SPEED()     \
X{       \
X  if (score > 50)     \
X    {       \
X      fall_speed = FALL_SPEED - (score / 25);  \
X      fall_speed = (fall_speed <= 10) ? 10 : fall_speed;\
X    }       \
X}
X
XMenu top_level_menu =
X{
X  0, 0, 0, Gen_Menu_Items,
X};
X  
Xchar *Gen_Menu_Items(i)
X     int i;
X{
X  switch (i)
X    {
X    case 0:
X      return "New Game";
X    case 1:
X      return ((running) ? "Stop" : "Start");
X    case 2:
X      return "Quit";
X    default:
X      return NULL;
X    }
X}
X  
X#define WAIT_TIME 5
X
XGamePiece *cgp, *ngp;
X
X
XDo_First_Move()
X{
X  int middle_x;
X
X  if (! running)
X    return 0;
X
X  middle_x = BOARD_WIDTH/2 -
X    (cgp->gmap_arr[cgp->cur]->rect.corner.x -
X     cgp->gmap_arr[cgp->cur]->rect.origin.x)/2;
X      
X  game_board.curpt = fPt(middle_x, 0);
X  /*
X  fprintf(stderr, "Do_First_Move(): game_board.curpt is (%d,%d)\n",
X   game_board.curpt.x, game_board.curpt.y
X   );
X  */
X  if (! Move_Piece(cgp, FirstMove)) /* first move and wont fit */
X    {
X      return 0;
X    }
X
X  return 1;
X}
X
Xstatic Point scoreloc, countloc;
XPoint nploc;
X
Xvoid Show_Score()
X{
X  char buff[16];
X
X  /* itoa((long) score, buff); */
X  Sprintf(buff, "%4d", score);
X  string(&largefont, buff, &display, add(Drect.origin, scoreloc), F_STORE);
X
X  /* itoa((long) p_count, buff); */
X  Sprintf(buff, "%4d", p_count);
X  string(&largefont, buff, &display, add(Drect.origin, countloc), F_STORE);
X}
X
Xvoid New_Game()
X{
X  Point q;
X
X  Clear_Game_Board();
X  Draw_Window();
X  q = add(Drect.origin, Srect.origin);
X  scoreloc = string(&largefont, " SCORE   ", &display, q, F_STORE);
X  scoreloc = sub(scoreloc, Drect.origin);
X
X  q = add(q, Pt(0, FONTHEIGHT(largefont)));
X  countloc = string(&largefont, " PIECES  ", &display, q, F_STORE);
X  countloc = sub(countloc, Drect.origin);
X
X  q = add(q, Pt(0, FONTHEIGHT(largefont)));
X  nploc = string(&largefont, " NEXT PIECE ", &display, q, F_STORE);
X  nploc = sub(nploc, Drect.origin);
X
X  ngp = Get_Next_Piece();
X  new_piece = 1;
X  running = 0;
X  p_count = 0;
X  score = 0;
X  fall_speed = FALL_SPEED;
X
X  Show_Score();
X}
X
Xvoid Collapse_Full_Rows()
X{
X  int n;
X
X  if (n = Show_Full_Rows(cgp))
X    Clear_Full_Rows(n, cgp);
X}
X
Xmain()
X{
X  extern GamePiece *Get_Next_Piece();
X  int bonus;
X
X  Initialize();
X  /* cache((char *) 0, A_NO_BOOT & ~A_SHARED); */
X  Reshape_Window();
X
X  request(MOUSE);
X  New_Game();
X
X  while (1)
X    {
X      alarm(0);
X      request(MOUSE);
X
X      while (! running)
X {
X   wait(MOUSE);
X   if ((own() & MOUSE) && button2())
X     {
X       int m = menuhit(&top_level_menu, 2);
X       switch (m)
X  {
X  default:
X    break;
X  case 0:
X    New_Game();
X    break;
X
X  case 1:
X    running = 1;
X    break;
X
X  case 2:
X    exit();
X  }
X     }
X }
X
X
X      alarm(fall_speed);
X      request(MOUSE|KBD|ALARM);
X      
X      while (running)
X {
X   Show_Score();
X   if (new_piece)
X     {
X       alarm(0);
X       Collapse_Full_Rows();
X       Clear_Shadow_Area();
X       cgp = ngp;
X       ngp = Get_Next_Piece();
X       cgp->cur = 0;
X       Show_Next_Piece(ngp);
X
X       if (! Do_First_Move())
X  {
X    running = 0;
X    new_piece = 1;
X    break;
X  }
X       p_count++;
X       new_piece = 0;
X       ADJUST_SPEED();
X       alarm(fall_speed);
X     }
X
X   wait(ALARM|MOUSE|KBD);
X   if ((own() & MOUSE) && button2())
X     {
X       int m = menuhit(&top_level_menu, 2);
X       switch (m)
X  {
X  default:
X    break;
X  case 0:
X    New_Game();
X    break;
X
X  case 1:
X    running = 0;
X    break;
X
X  case 2:
X    exit();
X  }
X
X       if (! running)
X  break;
X     }
X
X   if (own() & ALARM)
X     {
X       alarm(0);
X       if (Move_Piece(cgp, Down) < 0) /* resting */
X  {
X    score += cgp->score[cgp->cur];
X    new_piece = 1;
X    continue;
X  }
X
X       alarm(fall_speed);
X     }
X
X   if (own() & KBD)
X     {
X       switch (kbdchar())
X  {
X  default:
X    break;
X
X  case 0xE2: /* right arrow */
X  case 'l':
X    (void) Move_Piece(cgp, Right);
X    break;
X
X  case 0xE3: /* left arrow */
X  case 'h':
X    (void) Move_Piece(cgp, Left);
X    break;
X
X  case 0xE4: /* home key */
X  case 'j':
X    (void) Move_Piece(cgp, Clockwise);
X    break;
X
X  case 0xE0: /* up arrow */
X  case 'k':
X    (void) Move_Piece(cgp, CounterClockwise);
X    break;
X
X  case 0xE1: /* down arrow */
X  case ' ':
X    bonus = BOARD_HEIGHT - game_board.curpt.y;
X    (void) Move_Piece(cgp, Fall);
X    score += cgp->score[cgp->cur];
X    score += bonus/2; /* give them half the fall distance */
X
X    /* after a fall, the piece is always resting */
X    new_piece = 1;
X    break;
X  }
X     }
X }
X    }
X}
X
END-of-tetris.c
echo x - drawing.c
sed 's/^X//' >drawing.c << 'END-of-drawing.c'
X/**********************************************************/
X/*                                                        */
X/* Copyright (C) 1993 Fariborz ``Skip'' Tavakkoian        */
X/*                                                        */
X/**********************************************************/
X
Xstatic char *RCSid = "$Id: drawing.c,v 1.3 93/06/06 11:11:38 fst Exp $";
X
X/*
X * Description:
X *
X * $Log: drawing.c,v $
X * Revision 1.3  93/06/06  11:11:38  fst
X * Added the current game piece to argument list for Show_Full_Rows and
X * Clear_Full_Rows.  The two functions were changed to check those rows
X * which are effected by the last of move of the current game piece.
X * 
X * Revision 1.2  93/06/05  22:11:32  fst
X * Changed the RCS ``Header'' with ``Id''.
X * 
X * Revision 1.1  93/06/05  22:05:24  fst
X * Initial revision
X * 
X */
X
X#include <dmd.h>
X#include <dmdio.h>
X#include "tetris.h"
X
XTexture16 *colors[] =
X{
X  &T_darkgrey, 
X  (Texture16*) 0, /* black */
X  (Texture16*) 0, /* grey */
X  (Texture16*) 0, /* grey2 */
X  (Texture16*) 0, /* checks */
X  (Texture16*) 0, /* background */
X  &T_lightgrey,
X  (Texture16*) 0,
X};
X
XTexture16 hashmark =
X{
X  0x318C, 0x6318, 0xC631, 0x8C63,
X  0x18C6, 0x318C, 0x6318, 0xC631,
X  0x8C63, 0x18C6, 0x318C, 0x6318,
X  0xC631, 0x8C63, 0x18C6, 0x318C,
X};
X
Xstatic Word brick_bits[] =
X{
X  0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE,
X  0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE,
X  0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE,
X  0xFFFE, 0xFFFE, 0xFFFE, 0x0000,
X};
X
Xstatic Bitmap a_brick =
X{
X  (Word *) brick_bits,
X  1,
X  { {0, 0}, {16, 16} },
X  (char *) 0,
X};
X
Xstatic Word shadow_bits[64];
Xstatic Bitmap shadow =
X{
X  (Word *) shadow_bits,
X  1,    /* this changes at runtime */
X  { {0, 0}, {64, 16} },  /* so does corner.x  */
X  (char *) 0,
X};
X
Xstatic Word game_bits[BOARD_HEIGHT];
Xstatic Bitmap game_bitmap =
X{
X  (Word *) game_bits,
X  1,
X  { {0, 0}, {BOARD_WIDTH+1, BOARD_HEIGHT+1} },
X  (char *) 0,
X};
X
XBoard game_board =
X{
X  { 0, 0, },
X  &game_bitmap,
X};
X
X/* ================= J - piece ================ */
X
X/* -------------------  North ----------------- */
Xstatic Word xJ_n[] =
X{
X  0x4000,
X  0x4000,
X  0xC000,
X};
X
Xstatic Bitmap xJ_north =
X{
X  (Word *) xJ_n,
X  1,
X  { {0, 0}, {2, 3} },
X  (char *) 0,
X};
X
Xstatic Word J_n[96];
X
Xstatic Bitmap J_north =
X{
X  (Word *) J_n,
X  2,
X  { {0, 0}, {32, 48} },
X  (char *) 0,
X};
X
X/* ------------------  East ----------------- */
Xstatic Word xJ_e[] =
X{
X  0x8000,
X  0xE000,
X};
X
Xstatic Bitmap xJ_east =
X{
X  (Word *) xJ_e,
X  1,
X  { {0, 0}, {3, 2} },
X  (char *) 0,
X};
X
Xstatic Word J_e[96];
X
Xstatic Bitmap J_east =
X{
X  (Word*) J_e,
X  3,
X  { {0, 0}, {48, 32} },
X  (char *) 0,
X};
X
X/* ------------------- South ------------------ */
Xstatic Word xJ_s[] =
X{
X  0xC000,
X  0x8000,
X  0x8000,
X};
X
Xstatic Bitmap xJ_south =
X{
X  (Word *) xJ_s,
X  1,
X  { {0, 0}, {2, 3} },
X  (char *) 0,
X};
X
Xstatic Word J_s[96];
X
Xstatic Bitmap J_south =
X{
X  (Word*) J_s,
X  2,
X  { {0, 0}, {32, 48} },
X  (char *) 0,
X};
X
X
X/* ---------------------- West ------------------ */
Xstatic Word xJ_w[] =
X{
X  0xE000,
X  0x2000,
X};
X
Xstatic Bitmap xJ_west =
X{
X  (Word *) xJ_w,
X  1,
X  { {0, 0}, {3, 2} },
X  (char *) 0,
X};
X
Xstatic Word J_w[96];
X
Xstatic Bitmap J_west =
X{
X  (Word*) J_w,
X  3,
X  { {0, 0}, {48, 32} },
X  (char *) 0,
X};
X
X/* =================== L - piece ================== */
X
X/* ---------------------  North  ------------------ */
Xstatic Word xL_n[] =
X{
X  0x8000,
X  0x8000,
X  0xC000,
X};
X
Xstatic Bitmap xL_north =
X{
X  (Word *) xL_n,
X  1,
X  { {0, 0}, {2, 3} },
X  (char *) 0,
X};
X
Xstatic Word L_n[96];
X
Xstatic Bitmap L_north =
X{
X  (Word*) L_n,
X  2,
X  { {0, 0}, {32, 48} },
X  (char *) 0,
X};
X
X/* ---------------------  East  ------------------ */
Xstatic Word xL_e[] =
X{
X  0xE000,
X  0x8000,
X};
X
Xstatic Bitmap xL_east =
X{
X  (Word *) xL_e,
X  1,
X  { {0, 0}, {3, 2} },
X  (char *) 0,
X};
X
Xstatic Word L_e[96];
X
Xstatic Bitmap L_east =
X{
X  (Word*) L_e,
X  3,
X  { {0, 0}, {48, 32} },
X  (char *) 0,
X};
X
X/* --------------------  South  ------------------ */
Xstatic Word xL_s[] =
X{
X  0xC000,
X  0x4000,
X  0x4000,
X};
X
Xstatic Bitmap xL_south =
X{
X  (Word *) xL_s,
X  1,
X  { {0, 0}, {2, 3} },
X  (char *) 0,
X};
X
Xstatic Word L_s[96];
X
Xstatic Bitmap L_south =
X{
X  (Word*) L_s,
X  2,
X  { {0, 0}, {32, 48} },
X  (char *) 0,
X};
X
X/* ---------------------  West  ------------------ */
Xstatic Word xL_w[] =
X{
X  0x2000,
X  0xE000,
X};
X
Xstatic Bitmap xL_west =
X{
X  (Word *) xL_w,
X  1,
X  { {0, 0}, {3, 2} },
X  (char *) 0,
X};
X
Xstatic Word L_w[96];
X
Xstatic Bitmap L_west =
X{
X  (Word*) L_w,
X  3,
X  { {0, 0}, {48, 32} },
X  (char *) 0,
X};
X
X/* ================= S - peices ===================== */
X
X/* ------------------ North / South ----------------- */
Xstatic Word xS_n[] =
X{
X  0x8000,
X  0xC000,
X  0x4000,
X};
X
Xstatic Bitmap xS_north =
X{
X  (Word *) xS_n,
X  1,
X  { {0, 0}, {2, 3} },
X  (char *) 0,
X};
X
Xstatic Word S_n[96];
X
Xstatic Bitmap S_north =
X{
X  (Word *) S_n,
X  2,
X  { {0, 0}, {32, 48} },
X  (char *) 0,
X};
X
X/* ----------------- East / West ------------------ */
Xstatic Word xS_e[] =
X{
X  0x6000,
X  0xC000,
X};
X
Xstatic Bitmap xS_east =
X{
X  (Word *) xS_e,
X  1,
X  { {0, 0}, {3, 2} },
X  (char *) 0,
X};
X
Xstatic Word S_e[96];
X
Xstatic Bitmap S_east = 
X{
X  (Word *) S_e,
X  3,
X  { {0, 0}, {48, 32} },
X  (char *) 0,
X};
X
X/* =========================== Z - piece ======================= */
X
X/* -------------------------- North/South ---------------------- */
Xstatic Word xZ_n[] =
X{
X  0x4000,
X  0xC000,
X  0x8000,
X};
X
Xstatic Bitmap xZ_north =
X{
X  (Word *) xZ_n,
X  1,
X  { {0, 0}, {2, 3} },
X  (char *) 0,
X};
X
Xstatic Word Z_n[96];
Xstatic Bitmap Z_north =
X{
X  (Word *) Z_n,
X  2,
X  { {0, 0}, {32, 48} },
X  (char *) 0,
X};
X
X/* -------------------------- East/West ---------------------- */
Xstatic Word xZ_e[] =
X{
X  0xC000,
X  0x6000,
X};
X
Xstatic Bitmap xZ_east =
X{
X  (Word *) xZ_e,
X  1,
X  { {0, 0}, {3, 2} },
X  (char *) 0,
X};
X
Xstatic Word Z_e[96];
Xstatic Bitmap Z_east = 
X{
X  (Word *) Z_e,
X  3,
X  { {0, 0}, {48, 32} },
X  (char *) 0,
X};  
X
X/* ============================ T - piece ======================= */
X/* ---------------- North -------------- */
Xstatic Word xT_n[] =
X{
X  0x8000,
X  0xC000,
X  0x8000,
X};
X
Xstatic Bitmap xT_north = 
X{
X  (Word *) xT_n,
X  1,
X  { {0, 0}, {2, 3} },
X  (char *) 0,
X};
X
Xstatic Word T_n[96];
Xstatic Bitmap T_north = 
X{
X  (Word *) T_n,
X  2,
X  { {0, 0}, {32, 48} },
X  (char *) 0,
X};
X
X/* ------------------ East ----------------- */
Xstatic Word xT_e[] =
X{
X  0xE000,
X  0x4000,
X};
Xstatic Bitmap xT_east =
X{
X  (Word *) xT_e,
X  1,
X  { {0, 0}, {3, 2} },
X  (char *) 0,
X};
X
Xstatic Word T_e[96];
Xstatic Bitmap T_east = 
X{
X  (Word *) T_e,
X  3,
X  { {0, 0}, {48, 32} },
X  (char *) 0,
X};
X
X/* ------------------ South ---------------- */
Xstatic Word xT_s[] =
X{
X  0x4000,
X  0xC000,
X  0x4000,
X};
X
Xstatic Bitmap xT_south = 
X{
X  (Word *) xT_s,
X  1,
X  { {0, 0}, {2, 3} },
X  (char *) 0,
X};
X
Xstatic Word T_s[96];
Xstatic Bitmap T_south = 
X{
X  (Word *) T_s,
X  2,
X  { {0, 0}, {32, 48} },
X  (char *) 0,
X};
X
X/* -------------------- West ----------------- */  
Xstatic Word xT_w[] =
X{
X  0x4000,
X  0xE000,
X};
Xstatic Bitmap xT_west =
X{
X  (Word *) xT_w,
X  1,
X  { {0, 0}, {3, 2} },
X  (char *) 0,
X};
X
Xstatic Word T_w[96];
Xstatic Bitmap T_west = 
X{
X  (Word *) T_w,
X  3,
X  { {0, 0}, {48, 32} },
X  (char *) 0,
X};
X
X/* ========================= I - piece ===================== */
X
X/* ------------------------- North / South ----------------- */
Xstatic Word xI_n[] =
X{
X  0x8000,
X  0x8000,
X  0x8000,
X  0x8000,
X};
Xstatic Bitmap xI_north = 
X{
X  (Word *) xI_n,
X  1,
X  { {0, 0}, {1, 4} },
X  (char *) 0,
X};
X
Xstatic Word I_n[96];
Xstatic Bitmap I_north =
X{
X  (Word *) I_n,
X  1,
X  { {0, 0}, {16, 64} },
X  (char *) 0,
X};
X
X/* ------------------------- East / West ------------------- */
Xstatic Word xI_e[] =
X{
X  0xF000,
X};
Xstatic Bitmap xI_east = 
X{
X  (Word *) xI_e,
X  1,
X  { {0, 0}, {4, 1} },
X  (char *) 0,
X};
X
Xstatic Word I_e[96];
Xstatic Bitmap I_east =
X{
X  (Word *) I_e,
X  4,
X  { {0, 0}, {64, 16} },
X};
X
X/* ======================== Square piece ====================== */
X/* -------------------- North / South / East / West =========== */
Xstatic Word xO_n[] =
X{
X  0xC000,
X  0xC000,
X};
Xstatic Bitmap xO_north =
X{
X  (Word *) xO_n,
X  1,
X  { {0, 0}, {2, 2} },
X  (char *) 0,
X};
X
Xstatic Word O_n[96];
Xstatic Bitmap O_north =
X{
X  (Word *) O_n,
X  2,
X  { {0, 0}, {32, 32} },
X  (char *) 0,
X};
X    
X
X/* ============================================================ */
X
Xstatic GamePiece J_Piece =
X{
X  0, (Texture16 *) 0,
X  { 7, 6, 7, 6, },
X  { &xJ_north, &xJ_east, &xJ_south, &xJ_west, },
X  { &J_north, &J_east, &J_south, &J_west, },
X};
X
Xstatic GamePiece L_Piece =
X{
X  0, (Texture16 *) 0,
X  { 7, 6, 7, 6, },
X  { &xL_north, &xL_east, &xL_south, &xL_west, },
X  { &L_north, &L_east, &L_south, &L_west, },
X};
X
Xstatic GamePiece S_Piece =
X{
X  0, (Texture16 *) 0,
X  { 7, 6, 7, 6, },
X  { &xS_north, &xS_east, &xS_north, &xS_east, },
X  { &S_north, &S_east, &S_north, &S_east, },
X};
X
Xstatic GamePiece Z_Piece =
X{
X  0, (Texture16 *) 0,
X  { 7, 6, 7, 6, },
X  { &xZ_north, &xZ_east, &xZ_north, &xZ_east, },
X  { &Z_north, &Z_east, &Z_north, &Z_east, },
X};
X
Xstatic GamePiece T_Piece =
X{
X  0, (Texture16 *) 0,
X  { 5, 6, 5, 5, },
X  { &xT_north, &xT_east, &xT_south, &xT_west, },
X  { &T_north, &T_east, &T_south, &T_west, },
X};
X
Xstatic GamePiece I_Piece = 
X{
X  0, (Texture16 *) 0,
X  { 8, 5, 8, 5, },
X  { &xI_north, &xI_east, &xI_north, &xI_east, },
X  { &I_north, &I_east, &I_north, &I_east, },
X};
X
Xstatic GamePiece O_Piece =
X{
X  0, (Texture16 *) 0,
X  { 6, 6, 6, 6, },
X  { &xO_north, &xO_north, &xO_north, &xO_north, },
X  { &O_north, &O_north, &O_north, &O_north, },
X};
X
XGamePiece *Pieces[] =
X{
X  &O_Piece,
X  &I_Piece,
X  &J_Piece,
X  &L_Piece,
X  &S_Piece,
X  &Z_Piece,
X  &T_Piece,
X};
X
X/*
X * Pick a game piece. any piece...
X */
XGamePiece *Get_Next_Piece()
X{
X  return Pieces[rand() % 7];
X}
X
X/*
X * Set the color of a piece to a texture given.
X */
Xvoid Set_Color(smap, col)
X     Bitmap *smap;
X     Texture16 *col;
X{
X  texture(smap, smap->rect, col, F_OR);
X  texture(smap, smap->rect, col, F_XOR);
X}
X
Xint Show_Full_Rows(gp)
X     GamePiece *gp; /* the game piece that might have caused full rows */
X{
X  int y, xmax, ymax, ymin, rcount;
X  Word *w;
X  Bitmap *gbmap = game_board.map;
X
X  if (gp)
X    {
X      Bitmap *gpmap = gp->gmap_arr[gp->cur];
X
X      ymin = game_board.curpt.y;
X      ymax = game_board.curpt.y + gpmap->rect.corner.y;
X    }
X  else
X    {
X      ymin = gbmap->rect.origin.y;
X      ymax = gbmap->rect.corner.y;
X    }
X      
X  xmax = gbmap->rect.corner.x - 1;
X
X  for (rcount = 0, y = ymin; y < ymax; y++)
X    {
X      w = addr(gbmap, Pt(0, y));
X      if (*w == FULL_ROW_MASK)
X {
X   Rectangle r;
X
X   rcount++;
X   r.origin = add(add(Drect.origin, Grect.origin), mul(Pt(0, y), 16));
X   r.corner = add(r.origin, mul(Pt(xmax, 1), 16));
X   texture(&physical, r, &hashmark, F_STORE);
X   sleep(30);
X }
X    }
X
X  sleep(30);
X  return rcount;
X}
X
Xvoid Clear_Full_Rows(rcount, gp)
X     int rcount;
X     GamePiece *gp;
X{
X  int y, xmax, ymax, ymin;
X  Word *w;
X  Bitmap *gbmap = game_board.map;
X
X  if (gp)
X    {
X      Bitmap *gpmap = gp->gmap_arr[gp->cur];
X
X      ymin = game_board.curpt.y;
X      ymax = game_board.curpt.y + gpmap->rect.corner.y;
X    }
X  else
X    {
X      ymin = gbmap->rect.origin.y;
X      ymax = gbmap->rect.corner.y;
X    }
X
X  xmax = gbmap->rect.corner.x - 1;
X  while (rcount--)
X    {
X      for (y = ymax-1; y >= ymin; y--)
X {
X   w = addr(gbmap, Pt(0,y));
X   if (*w == FULL_ROW_MASK)
X     {
X       Point o;
X       Rectangle r;
X
X       /* move game rows down by 1 row */
X       bitblt(gbmap,Rpt(Pt(0,0), Pt(xmax, y)), gbmap, Pt(0,1), F_STORE);
X       /* clear the top game row */
X       rectf(gbmap, Rpt(Pt(0,0), Pt(xmax, 1)), F_CLR);
X
X       /* move displayed rows down by 1 row */
X       r.origin = add(Drect.origin, Grect.origin);
X       r.corner = add(r.origin, mul(Pt(xmax, y), 16));
X       o = add(r.origin, mul(Pt(0, 1), 16));
X       bitblt(&physical, r, &physical, o, F_STORE);
X
X       /* clear the top display row */
X       r.origin = add(Drect.origin, Grect.origin);
X       r.corner = add(r.origin, mul(Pt(xmax, 1), 16));
X       rectf(&physical, r, F_CLR);
X       break;
X     }
X }
X    }
X}
X
X/*
X * Using the game bitmap create the displayed piece shape.
X */
Xvoid Populate_Bitmap(gmap, smap)
X     Bitmap *gmap, *smap;
X{
X  int x, y;
X  int bit;
X  Word *w;
X
X  if (! eqpt(gmap->rect.origin, Pt(0,0)))
X    {
X      /* fprintf(stderr, "Populate_Bitmap(): Internal error\n"); */
X      sleep(2);
X      exit();
X    }
X  if (gmap->rect.corner.x > 4 || gmap->rect.corner.y > 4)
X    {
X      /* fprintf(stderr, "Populate_Bitmap(): Internal error\n"); */
X      sleep(2);
X      exit();
X    }
X
X  for (y = gmap->rect.origin.y; y < gmap->rect.corner.y; y++)
X    for (x = gmap->rect.origin.x; x < gmap->rect.corner.x; x++)
X    {
X      w = addr(gmap, Pt(x,y));
X
X      bit = FIRSTBIT >> (x % WORDSIZE);
X
X      /*
X       * If the bit is set fill the corresponding block
X       * in game piece's shape bitmap
X       */
X      if ((*w & bit) == bit)
X bitblt(&a_brick, a_brick.rect, smap, Pt((x*16),(y*16)), F_STORE);
X    }
X}
X
Xvoid Clear_Shadow_Area()
X{
X  rectf(&physical, raddp(Mrect, Drect.origin), F_CLR);
X}
X  
Xvoid Display_Shadow_XOR(gp)
X     GamePiece *gp;
X{
X  Point origin;
X  Bitmap *smap = gp->smap_arr[gp->cur];
X
X  /* Display the shadow */
X
X  origin = add(Drect.origin, Mrect.origin);
X  origin = add(origin, Pt(game_board.curpt.x*16, 0));
X
X  shadow.rect.corner.x = smap->rect.corner.x;
X  shadow.width = smap->width;
X
X  texture(&shadow, shadow.rect, (Texture16*) brick_bits, F_STORE);
X  texture(&shadow, shadow.rect, gp->color, F_XOR);
X  bitblt(&shadow, shadow.rect, &physical, origin, F_XOR);
X}
X
Xvoid Bitblit_Piece_XOR(gp)
X     GamePiece *gp;
X{
X  Point origin;
X  Bitmap *smap = gp->smap_arr[gp->cur];
X  Bitmap *gmap = gp->gmap_arr[gp->cur];
X
X  /* Game board bitmap */
X  origin = game_board.curpt;
X  bitblt(gmap, gmap->rect, game_board.map, origin, F_XOR);
X  
X  /* Display bitmap */
X
X  origin = fPt(add(add(Drect.origin, Grect.origin), mul(origin, 16)));
X  bitblt(smap, smap->rect, &physical, origin, F_XOR);
X  Display_Shadow_XOR(gp);
X}
X
Xvoid Bitblit_Display_XOR(gp)
X     GamePiece *gp;
X{
X  Point origin;
X  Bitmap *smap = gp->smap_arr[gp->cur];
X
X  origin = fPt(add(add(Drect.origin, Grect.origin),mul(game_board.curpt, 16)));
X
X  bitblt(smap, smap->rect, &physical, origin, F_XOR);
X  Display_Shadow_XOR(gp);
X}
X
Xvoid Bitblit_Game_Board_XOR(gp)
X     GamePiece *gp;
X{
X  Point origin;
X  Bitmap *gmap = gp->gmap_arr[gp->cur];
X
X  /* Game board bitmap */
X  origin = game_board.curpt;
X  bitblt(gmap, gmap->rect, game_board.map, origin, F_XOR);
X}
X
Xvoid Draw_Window()
X{
X  Rectangle r;
X
X  r.origin = sub(Srect.origin, Pt(1, 1));
X  r.corner = add(Srect.corner, Pt(1, 1));
X  r = raddp(r, Drect.origin);
X  box(&display, r, F_STORE);
X
X  r.origin = sub(Grect.origin, Pt(1, 1));
X  r.corner = add(Grect.corner, Pt(1, 1));
X  r = raddp(r, Drect.origin);
X  box(&display, r, F_STORE);
X
X  r.origin = sub(Mrect.origin, Pt(1, 1));
X  r.corner = add(Mrect.corner, Pt(1, 1));
X  r = raddp(r, Drect.origin);
X  box(&display, r, F_STORE);
X}
X
Xvoid Clear_Game_Board()
X{
X  extern Rectangle Grect;
X  Rectangle r;
X
X  r.origin = add(Drect.origin, Grect.origin);
X  r.corner = add(Drect.origin, Grect.corner);
X
X  /* rectf(&display, Drect, F_CLR); */
X  rectf(&display, r, F_CLR);
X  rectf(game_board.map, game_board.map->rect, F_CLR);
X  /* sleep(2); */
X}
X
Xvoid Show_Next_Piece(np)
X     GamePiece *np;
X{
X  Bitmap *smap = np->smap_arr[np->cur];
X  Rectangle r;
X
X  r.origin = add(Drect.origin, nploc);
X  r.corner = add(r.origin, Pt(64, 64));
X  rectf(&physical, r, F_CLR);
X  bitblt(smap, smap->rect, &physical, r.origin, F_STORE);
X}
END-of-drawing.c
echo x - motion.c
sed 's/^X//' >motion.c << 'END-of-motion.c'
X/**********************************************************/
X/*                                                        */
X/* Copyright (C) 1993 Fariborz ``Skip'' Tavakkolian       */
X/*                                                        */
X/**********************************************************/
X
Xstatic char *RCSid = "$Id: motion.c,v 1.2 93/06/05 22:11:28 fst Exp Locker: fst $";
X
X/*
X * Description:
X *
X * $Log: motion.c,v $
X * Revision 1.2  93/06/05  22:11:28  fst
X * Changed the RCS ``Header'' with ``Id''.
X * 
X * Revision 1.1  93/06/05  22:06:11  fst
X * Initial revision
X * 
X */
X
X#include <dmd.h>
X#include <dmdio.h>
X#include <font.h>
X#include "tetris.h"
X
Xvoid Reshape_Window()
X{
X  lprintf("Please Reshape Window");
X
X  request(RESHAPED);
X  do
X    {
X      wait(RESHAPED);
X      if (P->state & MOVED)
X {
X   P->state &= ~(MOVED|RESHAPED);
X }
X      else if ((P->state & RESHAPED) && !(P->state & MOVED))
X {
X   P->state &= ~RESHAPED;
X   P->state |= NO_RESHAPE;
X   break;
X }
X    }
X  while (1);
X}
X
X/*
X * Initialize the game pieces.
X */
Xvoid Init_Pieces()
X{
X  int i, j;
X  extern Texture16 *colors[];
X
X  for (i = 0; i < PIECES_COUNT; i++)
X    for (j = 0; j < 4; j++)
X      {
X Pieces[i]->color = colors[i];
X Populate_Bitmap(Pieces[i]->gmap_arr[j], Pieces[i]->smap_arr[j]);
X Set_Color(Pieces[i]->smap_arr[j], colors[i]);
X      }
X
X  srand((unsigned) realtime()); /* seed the random number generator */
X}
X
XRectangle Grect, Srect, Mrect;
X
X/*
X * Set default size for the window.
X */
XPoint default_size(x, y, p)
X     int x,y;
X     struct Proc *p;
X{
X  Point q;
X
X  Srect.origin = fPt(TET_INSET + BBW, TET_INSET + BBW);
X
X  Grect.origin = add(Srect.origin, Pt(TEXTWIDTH+2*BBW+TET_INSET, 0));
X  Grect.corner = add(Grect.origin, Pt(GBW, GBH));
X
X  Mrect.origin = add(Grect.origin, Pt(0, 2*BBW+GBH+TET_INSET));
X  Mrect.corner = add(Mrect.origin, Pt(GBW, 16));
X
X  Srect.corner = fPt(Srect.origin.x+TEXTWIDTH, Mrect.corner.y);
X
X  q.x = Grect.corner.x - Srect.origin.x + 2*TET_INSET + 2*BBW + 2*INSET;
X  q.y = Srect.corner.y - Srect.origin.y + 2*TET_INSET + 2*BBW + 2*INSET;
X
X  return q;
X}
X
X/*
X * Initialize the default size function, colors and pieces.
X */
Xvoid Initialize()
X{
X  colors[1] = &T_white;
X  colors[2] = &T_grey;
X  colors[3] = &T_grey2;
X  colors[4] = &T_checks;
X  colors[5] = &T_background;
X
X  Init_Pieces();
X
X  P->ctob = default_size;
X  P->state |= NOCURSEXPAND;
X}
X
Xint Check_Bounds(origin, corner)
X     Point origin, corner;
X{
X  /*
X  fprintf(stderr, "Check_Bounds origin(%d,%d), corner(%d,%d)\n",
X   origin.x, origin.y, corner.x, corner.y
X   );
X  */
X
X  if ((! ptinrect(origin, game_board.map->rect)) ||
X      (! ptinrect(corner, game_board.map->rect)))
X    return 0;
X
X  return 1;
X}
X
Xint Game_Board_Spot_Empty(gmap, pt)
X     Bitmap *gmap; /* game piece bitmap */
X     Point pt;  /* origin of game piece in game board bitmap */
X{
X  Point gpt, ept;
X  int x, y, maxx, maxy, bit;
X  Word *w;
X  extern Word *addr();
X
X  ept = add(pt, sub(gmap->rect.corner, gmap->rect.origin));
X  if (! Check_Bounds(pt, ept))
X    {
X      /*fprintf(stderr, "Game_Board_Spot_Empty(): Check_Bounds() failed\n");*/
X      return 0;
X    }
X
X  maxy = gmap->rect.corner.y;
X  maxx = gmap->rect.corner.x;
X
X  /*
X    For every bit set in the game piece bitmap
X    if corresponding bit in the game board bitmap, then fail
X    if all bits in game board are free, succeed.
X    */
X    
X  for (y = gmap->rect.origin.y; y < maxy; y++)
X    for (x = gmap->rect.origin.x; x < maxx; x++)
X      {
X w = addr(gmap, Pt(x, y));
X
X bit = FIRSTBIT >> (x % WORDSIZE);
X
X if ((*w & bit) == bit)
X   {
X     gpt = add(pt, Pt(x, y));
X
X     w = addr(game_board.map, gpt);
X     bit = FIRSTBIT >> (gpt.x % WORDSIZE);
X
X     if ((*w & bit) == bit)
X       {
X  /*
X  fprintf(stderr,
X   "Game_Board_Spot_Empty(): point(%d,%d) occupied\n",
X   gpt.x, gpt.y
X   );
X  */
X  return 0;
X       }
X   }
X      }
X
X  /*
X  fprintf(stderr,
X   "Game_Board_Spot_Empty(): rectangle([%d,%d],[%d,%d]) is open\n",
X   pt.x, pt.y, ept.x, ept.y
X   );
X  */
X  return 1;
X}
X
Xint Can_Move(gp, d, orgpt)
X     GamePiece *gp;
X     enum MoveDirection d;
X     Point *orgpt;
X{
X  switch ((int) d)
X    {
X    case Left:
X      *orgpt = sub(game_board.curpt, Pt(1, 0));
X      break;
X    case Right:
X      *orgpt = add(game_board.curpt, Pt(1, 0));
X      break;
X    case Down:
X      *orgpt = add(game_board.curpt, Pt(0, 1));
X      break;
X
X    default:
X      return 0;
X    }
X
X  return Game_Board_Spot_Empty(gp->gmap_arr[gp->cur], *orgpt);
X}
X
Xint Can_Rotate(gp, d, orgpt, orient)
X     GamePiece *gp;
X     enum MoveDirection d;
X     Point *orgpt;
X     int *orient;
X{
X  Point center;
X
X  switch ((int) d)
X    {
X    case Clockwise:
X      *orient = ((gp->cur + 1 > 3) ? 0 : gp->cur + 1);
X      break;
X    case CounterClockwise:
X      *orient = ((gp->cur - 1 < 0) ? 3 : gp->cur - 1);
X      break;
X    default:
X      return 0;
X    }
X
X
X  /* Center calculations */
X  center = add(game_board.curpt,
X        div(
X     sub(gp->gmap_arr[gp->cur]->rect.corner,
X         gp->gmap_arr[gp->cur]->rect.origin
X         ),
X     2)
X        );
X
X  /* New origin calculations */
X  *orgpt = sub(center,
X        div(
X     sub(gp->gmap_arr[*orient]->rect.corner,
X         gp->gmap_arr[*orient]->rect.origin
X         ),
X     2)
X        );
X
X  return Game_Board_Spot_Empty(gp->gmap_arr[*orient], *orgpt);
X}
X
Xint Move_Piece(gp, d)
X     GamePiece *gp;
X     enum MoveDirection d;
X{
X  int new_orientation;
X  Point new_origin;
X  int retval;
X
X  switch ((int) d)
X    {
X    case FirstMove:
X      if (! Game_Board_Spot_Empty(gp->gmap_arr[gp->cur], game_board.curpt))
X return 0;
X
X      break;
X
X    case Left:
X    case Right:
X    case Down:
X      Bitblit_Game_Board_XOR(gp); /* first free current location */
X      if (! Can_Move(gp, d, &new_origin))
X {
X   Bitblit_Game_Board_XOR(gp); /* put it back */
X   return ((d == Down) ? -1 : 0);
X }
X
X      Bitblit_Display_XOR(gp);  /* erase old impression */
X      game_board.curpt = new_origin;
X      break;
X
X    case Clockwise:
X    case CounterClockwise:
X      Bitblit_Game_Board_XOR(gp);
X      if (! Can_Rotate(gp, d, &new_origin, &new_orientation))
X {
X   Bitblit_Game_Board_XOR(gp); /* put it back */
X   return 0;
X }
X
X      Bitblit_Display_XOR(gp);
X      gp->cur = new_orientation;
X      game_board.curpt = new_origin;
X      break;
X
X    case Fall:
X      while ((retval = Move_Piece(gp, Down)) > 0)
X /* sleep(2) */;
X
X      return retval;
X    }
X
X  /*
X  fprintf(stderr,
X   "Move_Piece(): drawing (0x%x) at game_board location (%d,%d)\n",
X   gp, game_board.curpt.x, game_board.curpt.y
X   );
X  */
X  Bitblit_Piece_XOR(gp);
X  return 1;
X}
X
X  
END-of-motion.c
echo x - tetris.h
sed 's/^X//' >tetris.h << 'END-of-tetris.h'
X/**********************************************************/
X/*                                                        */
X/* Copyright (C) 1993 Fariborz ``Skip'' Tavakkolian       */
X/* All rights reserved                                    */
X/*                                                        */
X/**********************************************************/
X
X#ident "$Id: tetris.h,v 1.3 93/06/13 12:29:25 fst Exp $"
X
X/*
X * Description:
X *
X * $Log: tetris.h,v $
X * Revision 1.3  93/06/13  12:29:25  fst
X * Added forward declarations, and some external function declarations.
X * 
X * Revision 1.2  93/06/05  22:11:25  fst
X * Changed the RCS ``Header'' with ``Id''.
X * 
X * Revision 1.1  93/06/05  22:04:29  fst
X * Initial revision
X * 
X */
X
X#ifndef _tetris_h
X#define _tetris_h
X
X/* DMD Library Routines */
Xextern void bitblt();
Xextern void lprintf();
Xextern alarm();
Xextern int request();
Xextern int own();
Xextern int wait();
Xextern Point sPtCurrent();
X
X
X#define DIM(x) (sizeof(x)/sizeof((x)[0]))
X
X/* NOTE:
X   Do not set BOARD_WIDTH greater than 16
X   */
X#define BOARD_WIDTH 10
X#define BOARD_HEIGHT 30
X#define PIECES_COUNT 7
X
X#define TET_INSET 4
X#define BBW  1
X#define CHARCOUNT 18
X#define TEXTWIDTH (FONTWIDTH(largefont)*CHARCOUNT)
X#define GBW (BOARD_WIDTH * 16)
X#define GBH (BOARD_HEIGHT* 16)
X
X/* 1 tick = 1/60 of a second */
X#define FALL_SPEED 30
X
X/*
X  FULL_ROW_MASK greater than FFFF wont work
X  (see drawing.c Collapse_Full_Rows)
X  */
X#define FULL_ROW_MASK 0xFFC0
X
Xextern Texture16 hashmark;
X
Xenum MoveDirection
X{
X  FirstMove,
X  Fall,
X  Left,
X  Right,
X  Down,
X  Clockwise,
X  CounterClockwise,
X};
X
Xenum Boolean
X{
X  False = 0,
X  True,
X};
X
Xtypedef struct
X{
X  Point curpt;
X  Bitmap *map;
X} Board;
X
Xextern Board game_board;
X
Xtypedef struct
X{
X  int cur;
X  Texture16 *color; /* color for this game piece */
X  int score[4];  /* points scored for each orientation of the piece */
X  Bitmap *gmap_arr[4]; /* the game bitmap (one bit per brick)     */
X  Bitmap *smap_arr[4]; /* shape bit map.  This is built from gmap    */
X} GamePiece;
X
Xextern GamePiece *Pieces[];
Xextern Texture16 *colors[];
Xextern Rectangle Srect, Grect, Mrect;
Xextern Point nploc;
X
X#ifdef _STDC_
X# define __(x) x
X#else
X# define __(x) ()
X#endif
X
X/* dmdtetris functions */
Xextern GamePiece *Get_Next_Piece();
X
Xextern void Clear_Game_Board ();
Xextern void Draw_Window      ();
Xextern void Clear_Shadow_Area();
Xextern void Reshape_Window   ();
Xextern void Clear_Full_Rows  ();
Xextern void Init_Pieces      ();
Xextern void Initialize       ();
X
Xextern void Show_Next_Piece    __((GamePiece* ));
Xextern void Bitblit_Game_Board_XOR __((GamePiece* ));
Xextern void Bitblit_Display_XOR    __((GamePiece* ));
Xextern void Bitblit_Piece_XOR    __((GamePiece* ));
Xextern void Set_Color     __((Bitmap*, Texture16* ));
Xextern void Populate_Bitmap    __((Bitmap*, Bitmap* ));
X
Xextern int Show_Full_Rows();
X
Xextern Point default_size __((int x, int y, struct Proc* ));
X
X#endif /* _tetris_h */
END-of-tetris.h
exit