tkacik@kyzyl.mi.org (Tom Tkacik) (03/18/91)
Submitted-by: tkacik@kyzyl.mi.org (Tom Tkacik)
Posting-number: Volume 1, Issue 16
Archive-name: mahjongg/part02
#! /bin/sh
# This is a shell archive. Remove anything before this line, then unpack
# it by saving it into a file and typing "sh file". To overwrite existing
# files, type "sh file -c". You can also feed this as standard input via
# unshar, or by typing "sh <file", e.g.. If this archive is complete, you
# will see the following message at the end:
# "End of archive 2 (of 2)."
# Contents: character.c mahjongg.c other.c
# Wrapped by dave@galaxia on Wed Mar 13 21:44:30 1991
PATH=/bin:/usr/bin:/usr/ucb ; export PATH
if test -f 'character.c' -a "${1}" != "-c" ; then
echo shar: Will not clobber existing file \"'character.c'\"
else
echo shar: Extracting \"'character.c'\" \(9080 characters\)
sed "s/^X//" >'character.c' <<'END_OF_FILE'
X/* array cha1 contains a picture 48 pixels wide and 32 pixels high.
X for wrastop calls use srcwidth = 6, width = 48, and height = 32. */
Xunsigned short cha1[32][3] = {
X 0xffff, 0xffff, 0x07ff,
X 0x0001, 0x0000, 0x1c00,
X 0x0011, 0x0000, 0x2c00,
X 0x0019, 0x0000, 0xd400,
X 0x0011, 0x0000, 0xac00,
X 0x1c11, 0xe000, 0x5407,
X 0xf811, 0xffff, 0xac1f,
X 0xe011, 0x1fff, 0x5438,
X 0x8039, 0x001f, 0xac70,
X 0x0001, 0x0000, 0x5400,
X 0x0001, 0x0000, 0xac00,
X 0x0001, 0x1ff0, 0x5400,
X 0x0001, 0xd818, 0xac00,
X 0x0001, 0x7ffe, 0x5400,
X 0x0001, 0x0fe0, 0xac00,
X 0x0001, 0x0920, 0x5400,
X 0x0001, 0x0fe0, 0xac00,
X 0x0001, 0x0920, 0x5400,
X 0x0001, 0x0fe0, 0xac00,
X 0x0001, 0xe920, 0x5403,
X 0x0001, 0xfffc, 0xac0f,
X 0xc001, 0x1987, 0x543c,
X 0x7e01, 0x7fc0, 0xac70,
X 0x33c1, 0xc078, 0x5438,
X 0x6001, 0x000c, 0xac1c,
X 0x0001, 0x7000, 0x540e,
X 0x0001, 0xc000, 0xac03,
X 0x0001, 0x0000, 0x5400,
X 0xffff, 0xffff, 0xafff,
X 0xaaab, 0xaaaa, 0x5aaa,
X 0x555c, 0x5555, 0xb555,
X 0xaab0, 0xaaaa, 0xeaaa,
X};
X
X/* array cha2 contains a picture 48 pixels wide and 32 pixels high.
X for wrastop calls use srcwidth = 6, width = 48, and height = 32. */
Xunsigned short cha2[32][3] = {
X 0xffff, 0xffff, 0x07ff,
X 0x0001, 0x0000, 0x1c00,
X 0x0071, 0x3f80, 0x2c00,
X 0x0089, 0x7ffc, 0xd400,
X 0x0081, 0x0000, 0xac00,
X 0x3871, 0xc000, 0x540f,
X 0xf009, 0xffff, 0xac3f,
X 0xc009, 0x3fff, 0x5470,
X 0x00f9, 0x003f, 0xace0,
X 0x0001, 0x0000, 0x5400,
X 0x0001, 0x0000, 0xac00,
X 0x0001, 0x1ff0, 0x5400,
X 0x0001, 0xd818, 0xac00,
X 0x0001, 0x7ffe, 0x5400,
X 0x0001, 0x0fe0, 0xac00,
X 0x0001, 0x0920, 0x5400,
X 0x0001, 0x0fe0, 0xac00,
X 0x0001, 0x0920, 0x5400,
X 0x0001, 0x0fe0, 0xac00,
X 0x0001, 0xe920, 0x5403,
X 0x0001, 0xfffc, 0xac0f,
X 0xc001, 0x1987, 0x543c,
X 0x7e01, 0x7fc0, 0xac70,
X 0x33c1, 0xc078, 0x5438,
X 0x6001, 0x000c, 0xac1c,
X 0x0001, 0x7000, 0x540e,
X 0x0001, 0xc000, 0xac03,
X 0x0001, 0x0000, 0x5400,
X 0xffff, 0xffff, 0xafff,
X 0xaaab, 0xaaaa, 0x5aaa,
X 0x555c, 0x5555, 0xb555,
X 0xaab0, 0xaaaa, 0xeaaa,
X};
X
X/* array cha3 contains a picture 48 pixels wide and 32 pixels high.
X for wrastop calls use srcwidth = 6, width = 48, and height = 32. */
Xunsigned short cha3[32][3] = {
X 0xffff, 0xffff, 0x07ff,
X 0x0001, 0x0000, 0x1c00,
X 0x0071, 0x7f80, 0x2c00,
X 0x0089, 0x01fc, 0xd400,
X 0x0081, 0xfc00, 0xac01,
X 0x0071, 0x0ffe, 0x5400,
X 0xf081, 0xc000, 0xac03,
X 0xe089, 0xffff, 0x5407,
X 0xe071, 0x1fff, 0xac0e,
X 0x8001, 0x007f, 0x541c,
X 0x0001, 0x0000, 0xac00,
X 0x0001, 0x1ff0, 0x5400,
X 0x0001, 0xd818, 0xac00,
X 0x0001, 0x7ffe, 0x5400,
X 0x0001, 0x0fe0, 0xac00,
X 0x0001, 0x0920, 0x5400,
X 0x0001, 0x0fe0, 0xac00,
X 0x0001, 0x0920, 0x5400,
X 0x0001, 0x0fe0, 0xac00,
X 0x0001, 0xe920, 0x5403,
X 0x0001, 0xfffc, 0xac0f,
X 0xc001, 0x1987, 0x543c,
X 0x7e01, 0x7fc0, 0xac70,
X 0x33c1, 0xc078, 0x5438,
X 0x6001, 0x000c, 0xac1c,
X 0x0001, 0x7000, 0x540e,
X 0x0001, 0xc000, 0xac03,
X 0x0001, 0x0000, 0x5400,
X 0xffff, 0xffff, 0xafff,
X 0xaaab, 0xaaaa, 0x5aaa,
X 0x555c, 0x5555, 0xb555,
X 0xaab0, 0xaaaa, 0xeaaa,
X};
X
X/* array cha4 contains a picture 48 pixels wide and 32 pixels high.
X for wrastop calls use srcwidth = 6, width = 48, and height = 32. */
Xunsigned short cha4[32][3] = {
X 0xffff, 0xffff, 0x07ff,
X 0x0001, 0x0000, 0x1c00,
X 0x0081, 0x0000, 0x2c00,
X 0x00c1, 0xf000, 0xd403,
X 0x00a1, 0xfff0, 0xac07,
X 0xc091, 0x18ff, 0x540e,
X 0xf089, 0x1861, 0xac1e,
X 0xe1f9, 0x1c61, 0x540f,
X 0x8081, 0xfff3, 0xac07,
X 0x0001, 0x003e, 0x5400,
X 0x0001, 0x0000, 0xac00,
X 0x0001, 0x1ff0, 0x5400,
X 0x0001, 0xd818, 0xac00,
X 0x0001, 0x7ffe, 0x5400,
X 0x0001, 0x0fe0, 0xac00,
X 0x0001, 0x0920, 0x5400,
X 0x0001, 0x0fe0, 0xac00,
X 0x0001, 0x0920, 0x5400,
X 0x0001, 0x0fe0, 0xac00,
X 0x0001, 0xe920, 0x5403,
X 0x0001, 0xfffc, 0xac0f,
X 0xc001, 0x1987, 0x543c,
X 0x7e01, 0x7fc0, 0xac70,
X 0x33c1, 0xc078, 0x5438,
X 0x6001, 0x000c, 0xac1c,
X 0x0001, 0x7000, 0x540e,
X 0x0001, 0xc000, 0xac03,
X 0x0001, 0x0000, 0x5400,
X 0xffff, 0xffff, 0xafff,
X 0xaaab, 0xaaaa, 0x5aaa,
X 0x555c, 0x5555, 0xb555,
X 0xaab0, 0xaaaa, 0xeaaa,
X};
X
X/* array cha5 contains a picture 48 pixels wide and 32 pixels high.
X for wrastop calls use srcwidth = 6, width = 48, and height = 32. */
Xunsigned short cha5[32][3] = {
X 0xffff, 0xffff, 0x07ff,
X 0x0001, 0x0000, 0x1c00,
X 0x00f9, 0xc006, 0x2c03,
X 0x0009, 0xff1e, 0xd400,
X 0x0009, 0x1c0e, 0xac00,
X 0x0079, 0x0c07, 0x5400,
X 0x8081, 0xfe07, 0xac03,
X 0xc081, 0x0c06, 0x5403,
X 0x6079, 0x8e06, 0xac01,
X 0x0001, 0xff86, 0x5403,
X 0x0001, 0x0000, 0xac0f,
X 0x0001, 0x1ff0, 0x5400,
X 0x0001, 0xd818, 0xac00,
X 0x0001, 0x7ffe, 0x5400,
X 0x0001, 0x0fe0, 0xac00,
X 0x0001, 0x0920, 0x5400,
X 0x0001, 0x0fe0, 0xac00,
X 0x0001, 0x0920, 0x5400,
X 0x0001, 0x0fe0, 0xac00,
X 0x0001, 0xe920, 0x5403,
X 0x0001, 0xfffc, 0xac0f,
X 0xc001, 0x1987, 0x543c,
X 0x7e01, 0x7fc0, 0xac70,
X 0x33c1, 0xc078, 0x5438,
X 0x6001, 0x000c, 0xac1c,
X 0x0001, 0x7000, 0x540e,
X 0x0001, 0xc000, 0xac03,
X 0x0001, 0x0000, 0x5400,
X 0xffff, 0xffff, 0xafff,
X 0xaaab, 0xaaaa, 0x5aaa,
X 0x555c, 0x5555, 0xb555,
X 0xaab0, 0xaaaa, 0xeaaa,
X};
X
X/* array cha6 contains a picture 48 pixels wide and 32 pixels high.
X for wrastop calls use srcwidth = 6, width = 48, and height = 32. */
Xunsigned short cha6[32][3] = {
X 0xffff, 0xffff, 0x07ff,
X 0x0001, 0x0000, 0x1c00,
X 0x0071, 0x1e00, 0x2c00,
X 0x0089, 0x0e00, 0xd400,
X 0x0009, 0x0600, 0xac00,
X 0x0079, 0xfffe, 0x5407,
X 0x8089, 0x3f87, 0xac3e,
X 0x0089, 0xf1e0, 0x5400,
X 0x0071, 0xc078, 0xac03,
X 0x0001, 0x803e, 0x5403,
X 0x0001, 0x0000, 0xac00,
X 0x0001, 0x1ff0, 0x5400,
X 0x0001, 0xd818, 0xac00,
X 0x0001, 0x7ffe, 0x5400,
X 0x0001, 0x0fe0, 0xac00,
X 0x0001, 0x0920, 0x5400,
X 0x0001, 0x0fe0, 0xac00,
X 0x0001, 0x0920, 0x5400,
X 0x0001, 0x0fe0, 0xac00,
X 0x0001, 0xe920, 0x5403,
X 0x0001, 0xfffc, 0xac0f,
X 0xc001, 0x1987, 0x543c,
X 0x7e01, 0x7fc0, 0xac70,
X 0x33c1, 0xc078, 0x5438,
X 0x6001, 0x000c, 0xac1c,
X 0x0001, 0x7000, 0x540e,
X 0x0001, 0xc000, 0xac03,
X 0x0001, 0x0000, 0x5400,
X 0xffff, 0xffff, 0xafff,
X 0xaaab, 0xaaaa, 0x5aaa,
X 0x555c, 0x5555, 0xb555,
X 0xaab0, 0xaaaa, 0xeaaa,
X};
X
X/* array cha7 contains a picture 48 pixels wide and 32 pixels high.
X for wrastop calls use srcwidth = 6, width = 48, and height = 32. */
Xunsigned short cha7[32][3] = {
X 0xffff, 0xffff, 0x07ff,
X 0x0001, 0x0000, 0x1c00,
X 0x00f9, 0x0000, 0x2c00,
X 0x8081, 0xe00f, 0xd403,
X 0x8081, 0xf81f, 0xac1f,
X 0x0041, 0x1f30, 0x541f,
X 0x0021, 0x03e0, 0xac00,
X 0x0021, 0x00f8, 0x5400,
X 0x8021, 0x3fcf, 0xac00,
X 0xf001, 0x3f03, 0x5400,
X 0xf001, 0x0001, 0xac00,
X 0x0001, 0x1ff0, 0x5400,
X 0x0001, 0xd818, 0xac00,
X 0x0001, 0x7ffe, 0x5400,
X 0x0001, 0x0fe0, 0xac00,
X 0x0001, 0x0920, 0x5400,
X 0x0001, 0x0fe0, 0xac00,
X 0x0001, 0x0920, 0x5400,
X 0x0001, 0x0fe0, 0xac00,
X 0x0001, 0xe920, 0x5403,
X 0x0001, 0xfffc, 0xac0f,
X 0xc001, 0x1987, 0x543c,
X 0x7e01, 0x7fc0, 0xac70,
X 0x33c1, 0xc078, 0x5438,
X 0x6001, 0x000c, 0xac1c,
X 0x0001, 0x7000, 0x540e,
X 0x0001, 0xc000, 0xac03,
X 0x0001, 0x0000, 0x5400,
X 0xffff, 0xffff, 0xafff,
X 0xaaab, 0xaaaa, 0x5aaa,
X 0x555c, 0x5555, 0xb555,
X 0xaab0, 0xaaaa, 0xeaaa,
X};
X
X/* array cha8 contains a picture 48 pixels wide and 32 pixels high.
X for wrastop calls use srcwidth = 6, width = 48, and height = 32. */
Xunsigned short cha8[32][3] = {
X 0xffff, 0xffff, 0x07ff,
X 0x0001, 0x0000, 0x1c00,
X 0x0071, 0x0f80, 0x2c00,
X 0x0089, 0x1f80, 0xd400,
X 0x0089, 0x3800, 0xac00,
X 0x0071, 0x61f0, 0x5400,
X 0x0089, 0xc1f8, 0xac01,
X 0x0089, 0x801e, 0x540f,
X 0x8071, 0x0003, 0xac1e,
X 0xe001, 0x0000, 0x5400,
X 0x0001, 0x0000, 0xac00,
X 0x0001, 0x1ff0, 0x5400,
X 0x0001, 0xd818, 0xac00,
X 0x0001, 0x7ffe, 0x5400,
X 0x0001, 0x0fe0, 0xac00,
X 0x0001, 0x0920, 0x5400,
X 0x0001, 0x0fe0, 0xac00,
X 0x0001, 0x0920, 0x5400,
X 0x0001, 0x0fe0, 0xac00,
X 0x0001, 0xe920, 0x5403,
X 0x0001, 0xfffc, 0xac0f,
X 0xc001, 0x1987, 0x543c,
X 0x7e01, 0x7fc0, 0xac70,
X 0x33c1, 0xc078, 0x5438,
X 0x6001, 0x000c, 0xac1c,
X 0x0001, 0x7000, 0x540e,
X 0x0001, 0xc000, 0xac03,
X 0x0001, 0x0000, 0x5400,
X 0xffff, 0xffff, 0xafff,
X 0xaaab, 0xaaaa, 0x5aaa,
X 0x555c, 0x5555, 0xb555,
X 0xaab0, 0xaaaa, 0xeaaa,
X};
X
X/* array cha9 contains a picture 48 pixels wide and 32 pixels high.
X for wrastop calls use srcwidth = 6, width = 48, and height = 32. */
Xunsigned short cha9[32][3] = {
X 0xffff, 0xffff, 0x07ff,
X 0x0001, 0x0000, 0x1c00,
X 0x0071, 0x0018, 0x2c00,
X 0x0089, 0x7fff, 0xd400,
X 0x0089, 0x3ff8, 0xac00,
X 0x00f1, 0x0e78, 0x5408,
X 0x0081, 0x0e38, 0xac08,
X 0x0089, 0x1e1c, 0x5408,
X 0x0071, 0xf80e, 0xac08,
X 0x8001, 0xc003, 0x541f,
X 0xe001, 0x0000, 0xac00,
X 0x0001, 0x1ff0, 0x5400,
X 0x0001, 0xd818, 0xac00,
X 0x0001, 0x7ffe, 0x5400,
X 0x0001, 0x0fe0, 0xac00,
X 0x0001, 0x0920, 0x5400,
X 0x0001, 0x0fe0, 0xac00,
X 0x0001, 0x0920, 0x5400,
X 0x0001, 0x0fe0, 0xac00,
X 0x0001, 0xe920, 0x5403,
X 0x0001, 0xfffc, 0xac0f,
X 0xc001, 0x1987, 0x543c,
X 0x7e01, 0x7fc0, 0xac70,
X 0x33c1, 0xc078, 0x5438,
X 0x6001, 0x000c, 0xac1c,
X 0x0001, 0x7000, 0x540e,
X 0x0001, 0xc000, 0xac03,
X 0x0001, 0x0000, 0x5400,
X 0xffff, 0xffff, 0xafff,
X 0xaaab, 0xaaaa, 0x5aaa,
X 0x555c, 0x5555, 0xb555,
X 0xaab0, 0xaaaa, 0xeaaa,
X};
END_OF_FILE
if test 9080 -ne `wc -c <'character.c'`; then
echo shar: \"'character.c'\" unpacked with wrong size!
fi
# end of 'character.c'
fi
if test -f 'mahjongg.c' -a "${1}" != "-c" ; then
echo shar: Will not clobber existing file \"'mahjongg.c'\"
else
echo shar: Extracting \"'mahjongg.c'\" \(11675 characters\)
sed "s/^X//" >'mahjongg.c' <<'END_OF_FILE'
X/*
X * This program contains much of the code from the original
X * Sun version of mahjongg, written by Mark Holm, which was
X * inspired by the PC version.
X *
X * This version of Mahjongg was modified/re-written/ported
X * for/to the AT&T UNIXPC by Thomas Tkacik
X * tkacik@kyzyl.mi.org
X *
X * Any problems or comments should be addressed to Tom Tkacik
X * and not Mark Holm, who had nothing to do with this version
X * and will not be able to help you.
X *
X */
X
X/*
X * Copyright 1988, Mark Holm
X * Exceptions
X *
X * Permission is given to copy and distribute for non-profit purposes.
X *
X */
X
X#include <stdio.h>
X#include <fcntl.h>
X#include <termio.h>
X#include <sys/signal.h>
X#include <tam.h>
X#include <sys/font.h>
X#include <sys/mouse.h>
X#include "mahjongg.h"
X
Xvoid srand48();
Xlong lrand48();
Xdouble drand48();
Xlong time();
Xlong atol();
Xvoid exit();
X
X/* number used to generate the current board */
Xlong board;
X
X/* should we use inverse video for the pieces? */
X#ifdef INVERSE_VIDEO
Xint invert = 1;
X#else
Xint invert = 0;
X#endif
X
Xmain(argc, argv)
Xint argc;
Xchar *argv[];
X{
X int c, errflg = 0;
X extern int optind;
X extern char *optarg;
X
X initrandom();
X
X /* parse arguments */
X
X while((c = getopt(argc, argv, "bin:")) != EOF) {
X switch(c) {
X case 'b':
X invert = 0;
X break;
X case 'i':
X invert = 1;
X break;
X case 'n':
X board = atol(optarg);
X srand48(board);
X break;
X default:
X errflg = 1;
X }
X }
X if(errflg == 1) {
X fprintf(stderr, "Usage: mahjongg [-i][-b][-n #]\n");
X exit(1);
X }
X
X /* attempt to make tiles look a little better for inverse video */
X /* this is a real hack, but it's easier than redesigning the tiles */
X
X if(invert == 1) {
X int i;
X for(i = 0; i < NUMIMAGES; i++) {
X images[i][2] = 0xffff;
X images[i][5] ^= 0xe800;
X images[i][8] ^= 0xc000;
X images[i][87] = 0xaaab;
X images[i][90] = 0x5557;
X images[i][93] = 0xaaaf;
X images[i][95] = 0x6aaa;
X }
X }
X
X initwindow();
X
X initmouse();
X
X start_game();
X wcmd(wn, "starting new game");
X
X dispatch();
X
X leave();
X
X /*NOTREACHED*/
X}
X
X/*
X * get an initial random number from the process id
X */
X
Xinitrandom()
X{
X long time();
X
X
X srand48(getpid() + time((long *)0));
X
X /* let board be the first number in the random sequence */
X /* this will vary more than (getpid+time) does */
X
X board = (lrand48())>>15;
X srand48(board);
X}
X
X/*
X * read input and call appropriate routines
X */
X
Xdispatch()
X{
X int c;
X
X for(;;) {
X c = wgetc(wn);
X switch(c) {
X case F1:
X help();
X break;
X case F2:
X start_game();
X break;
X case F3:
X new();
X break;
X case F4:
X undo_proc();
X break;
X case F5:
X quit();
X return;
X break;
X case Mouse:
X domouse();
X break;
X default:
X /* ignore all other input */
X break;
X }
X }
X}
X
X/*
X * start a new game
X */
X
Xnew()
X{
X /* use only the high 16 significant bits of board */
X
X board = (lrand48())>>15;
X
X start_game();
X
X wcmd(wn, "starting new game");
X}
X
X/*
X * play the game with the current board number
X */
X
Xstart_game()
X{
X srand48(board);
X
X tile_count = 144;
X
X /* set the tiles up for randomizing */
X
X initmahjongg();
X
X draw_tiles();
X
X wcmd(wn, "replaying same game");
X wprompt(wn, "");
X}
X
X/*
X * when the help button is pushed
X */
X
Xhelp()
X{
X if((selected[0] != -1) && !help_mode) {
X
X /* in query mode */
X
X help_proc();
X } else {
X
X /* not in query mode */
X
X query_mode = FALSE;
X
X /* cancel preview of selected tiles */
X
X preview_tile(selected[0]);
X preview_tile(selected[1]);
X
X /* Clean up selected's variables */
X
X selected[0] = -1;
X selected[1] = -1;
X
X /* do next help */
X
X help_proc();
X }
X}
X
X/*
X * when the quit button is pushed
X */
X
Xquit()
X{
X wcmd(wn, "quit");
X wprompt(wn, " ");
X}
X
X/*
X * when one of the mouse buttons is pushed
X */
X
Xdomouse()
X{
X int i;
X int x, y, buttons, reason;
X
X wreadmouse(wn, &x, &y, &buttons, &reason);
X
X /* see if the mouse is in a free tile */
X
X for(i = NUMTILES-1; i >= 0; i--) {
X if((x >= tiles[i].x_pos) &&
X (x < tiles[i].x_pos + TILE_X) &&
X (y >= tiles[i].y_pos) &&
X (y < tiles[i].y_pos + TILE_Y) &&
X (tiles[i].removed == FALSE) &&
X (tiles[i].top_free == TRUE) &&
X ((tiles[i].left_free == TRUE) ||
X (tiles[i].right_free == TRUE))) {
X break;
X }
X }
X
X /* i will equal -1 if not on a legal tile */
X play_event_proc(i, buttons);
X}
X
X/*
X * initialize the mahjongg tiles
X */
X
Xinitmahjongg()
X{
X int i, j;
X
X selected[0] = -1;
X selected[1] = -1;
X undo_count = -1;
X
X wcmd(wn,"Building board. Please Wait.");
X
X /* set up tiles for shuffling */
X
X for(i = 0, j = 0; i < 34; i+=1, j+=4) {
X tiles[j].value = i;
X tiles[j].image = images[i];
X tiles[j+1].value = i;
X tiles[j+1].image = images[i];
X tiles[j+2].value = i;
X tiles[j+2].image = images[i];
X tiles[j+3].value = i;
X tiles[j+3].image = images[i];
X }
X
X /* now the one of a kind tiles */
X
X for(i = 34, j = 136; i < 36; i+=1, j+=4) {
X tiles[j].value = i;
X tiles[j].image = images[j-136+34];
X tiles[j+1].value = i;
X tiles[j+1].image = images[j-136+34 + 1];
X tiles[j+2].value = i;
X tiles[j+2].image = images[j-136+34 + 2];
X tiles[j+3].value = i;
X tiles[j+3].image = images[j-136+34 + 3];
X }
X
X /* shuffle tiles */
X
X for(i = NUMTILES-1; i > 0 ; i--) {
X Tile temp;
X
X /* a random integer between 0 and i */
X
X j = drand48() * (i+1);
X
X /* swap tiles */
X
X temp = tiles[i];
X tiles[i] = tiles[j];
X tiles[j] = temp;
X }
X
X position_tiles();
X}
X
X/*
X * give each tile a position on the playing board
X */
X
Xposition_tiles()
X{
X int i, j;
X int x_pos, y_pos;
X
X /* give each tile a position on the board */
X
X /* ROW 1 */
X x_pos = X_OFF2;
X y_pos = Y_OFF1;
X for(i = 0; i < 12; i++) {
X init_tile(i, x_pos, y_pos);
X x_pos += TILE_X;
X }
X tiles[0].left_free = TRUE;
X tiles[0].left_next[0] = -1;
X tiles[11].right_free = TRUE;
X tiles[11].right_next[0] = -1;
X
X /* ROW 2 */
X x_pos = X_OFF4;
X y_pos = Y_OFF2;
X for(i = 12; i < 20; i++) {
X init_tile(i, x_pos, y_pos);
X x_pos += TILE_X;
X }
X tiles[12].left_free = TRUE;
X tiles[12].left_next[0] = -1;
X tiles[19].right_free = TRUE;
X tiles[19].right_next[0] = -1;
X
X /* ROW 3 */
X x_pos = X_OFF3;
X y_pos = Y_OFF3;
X for(i = 20; i < 30; i++) {
X init_tile(i, x_pos, y_pos);
X x_pos += TILE_X;
X }
X tiles[20].left_free = TRUE;
X tiles[20].left_next[0] = -1;
X tiles[29].right_free = TRUE;
X tiles[29].right_next[0] = -1;
X
X /* ROW 4 1/2 Left side */
X x_pos = X_OFF1;
X y_pos = Y_OFF45;
X init_tile(30, x_pos, y_pos);
X tiles[30].left_free = TRUE;
X tiles[30].left_next[0] = -1;
X tiles[30].right_next[1] = 43;
X
X /* ROW 4 */
X x_pos = X_OFF2;
X y_pos = Y_OFF4;
X for(i = 31; i < 43; i++) {
X init_tile(i, x_pos, y_pos);
X x_pos += TILE_X;
X }
X tiles[42].right_next[0] = 55;
X
X /* ROW 5 */
X x_pos = X_OFF2;
X y_pos = Y_OFF5;
X for(i = 43; i < 55; i++) {
X init_tile(i, x_pos, y_pos);
X x_pos += TILE_X;
X }
X tiles[43].left_next[0] = 30;
X
X /* ROW 4 1/2 Right side */
X x_pos = X_OFF14;
X y_pos = Y_OFF45;
X for(i = 55; i < 57; i++) {
X init_tile(i, x_pos, y_pos);
X x_pos += TILE_X;
X }
X tiles[55].left_next[1] = 42;
X tiles[56].right_free = TRUE;
X tiles[56].right_next[0] = -1;
X
X /* ROW 6 */
X x_pos = X_OFF3;
X y_pos = Y_OFF6;
X for(i = 57; i < 67; i++) {
X init_tile(i, x_pos, y_pos);
X x_pos += TILE_X;
X }
X tiles[57].left_free = TRUE;
X tiles[57].left_next[0] = -1;
X tiles[66].right_free = TRUE;
X tiles[66].right_next[0] = -1;
X
X /* ROW 7 */
X x_pos = X_OFF4;
X y_pos = Y_OFF7;
X for(i = 67; i < 75; i++) {
X init_tile(i, x_pos, y_pos);
X x_pos += TILE_X;
X }
X tiles[67].left_free = TRUE;
X tiles[67].left_next[0] = -1;
X tiles[74].right_free = TRUE;
X tiles[74].right_next[0] = -1;
X
X /* ROW 8 */
X x_pos = X_OFF2;
X y_pos = Y_OFF8;
X for(i = 75; i < 87; i++) {
X init_tile(i, x_pos, y_pos);
X x_pos += TILE_X;
X }
X tiles[75].left_free = TRUE;
X tiles[75].left_next[0] = -1;
X tiles[86].right_free = TRUE;
X tiles[86].right_next[0] = -1;
X
X /* LEVEL 2 */
X x_pos = X_OFF5 + X_OFFL2;
X y_pos = Y_OFF2 + Y_OFFL2;
X for(i = 87; i < 123; i+=6) {
X for(j = 0; j < 6; j++) {
X init_tile(i+j, x_pos, y_pos);
X x_pos += TILE_X;
X }
X x_pos = X_OFF5 + X_OFFL2;
X y_pos += TILE_Y;
X tiles[i].left_free = TRUE;
X tiles[i].left_next[0] = -1;
X tiles[i+5].right_free = TRUE;
X tiles[i+5].right_next[0] = -1;
X }
X
X /* LEVEL 3 */
X x_pos = X_OFF6 + X_OFFL3;
X y_pos = Y_OFF3 + Y_OFFL3;
X for(i = 123; i < 139; i+=4) {
X for(j = 0; j < 4; j++) {
X init_tile(i+j, x_pos, y_pos);
X x_pos += TILE_X;
X }
X x_pos = X_OFF6 + X_OFFL3;
X y_pos += TILE_Y;
X tiles[i].left_free = TRUE;
X tiles[i].left_next[0] = -1;
X tiles[i+3].right_free = TRUE;
X tiles[i+3].right_next[0] = -1;
X }
X
X /* LEVEL 4 */
X x_pos = X_OFF7 + X_OFFL4;
X y_pos = Y_OFF4 + Y_OFFL4;
X for(i = 139; i < 143; i+=2) {
X for(j = 0; j < 2; j++) {
X init_tile(i+j, x_pos, y_pos);
X x_pos += TILE_X;
X }
X x_pos = X_OFF7 + X_OFFL4;
X y_pos += TILE_Y;
X tiles[i].left_free = TRUE;
X tiles[i].left_next[0] = -1;
X tiles[i+1].right_free = TRUE;
X tiles[i+1].right_next[0] = -1;
X }
X tiles[139].top_free = FALSE;
X tiles[140].top_free = FALSE;
X tiles[141].top_free = FALSE;
X tiles[142].top_free = FALSE;
X
X /* LEVEL 5 */
X x_pos = X_OFF75 + X_OFFL5;
X y_pos = Y_OFF45 + Y_OFFL5;
X init_tile(143, x_pos, y_pos);
X tiles[143].left_free = TRUE;
X tiles[143].left_next[0] = -1;
X tiles[143].right_free = TRUE;
X tiles[143].right_next[0] = -1;
X tiles[143].covered[0] = 139;
X tiles[143].covered[1] = 140;
X tiles[143].covered[2] = 141;
X tiles[143].covered[3] = 142;
X
X /* this code copied verbatim from Mark Holm's Mahjongg */
X /* set top_free flags and covered pointers */
X
X for(i = 87, j = 13; i < 143; i++, j++) {
X tiles[i].covered[0] = j;
X tiles[j].top_free = FALSE;
X switch(j) {
X case 97:
X case 103:
X case 109:
X case 129:
X j += 2;
X break;
X case 18:
X case 64:
X j += 3;
X break;
X case 27:
X case 39:
X j += 6;
X break;
X case 51:
X j += 7;
X break;
X case 73:
X j += 20;
X break;
X case 115:
X j += 12;
X break;
X }
X }
X}
X
X/*
X * give tile i its default initial values
X */
X
Xinit_tile(i, x_pos, y_pos)
Xint i;
Xint x_pos, y_pos;
X{
X tiles[i].x_pos = x_pos;
X tiles[i].y_pos = y_pos;
X tiles[i].left_free = FALSE;
X tiles[i].right_free = FALSE;
X tiles[i].top_free = TRUE;
X tiles[i].left_next[0] = i - 1;
X tiles[i].left_next[1] = -1;
X tiles[i].right_next[0] = i + 1;
X tiles[i].right_next[1] = -1;
X tiles[i].covered[0] = -1;
X tiles[i].covered[1] = -1;
X tiles[i].covered[2] = -1;
X tiles[i].covered[3] = -1;
X tiles[i].removed = FALSE;
X}
X
X/*
X * draw the tiles on the playing field
X */
X
Xdraw_tiles()
X{
X /* draw in playing_area and then copy to window */
X static unsigned short playing_area[ROWS*12*COLS*9/16];
X
X int i = 0;
X wgoto(wn, 1, 23);
X wprintf(wn, "Tiles Remaining: %3d", tile_count);
X wgoto(wn, 1, 53);
X wprintf(wn, "Board Number: %5ld", board);
X
X /* clear the playing field */
X
X wrastop(wn, 0, 0, playing_area, COLS*9/8, 0, 0,
X X_OFF1, Y_OFF1, 14*TILE_X+TILE_W, 7*TILE_Y+TILE_H,
X SRCPAT, DSTSRC, patblack);
X
X /* place tiles */
X
X for(i = 0; i < NUMTILES; i++) {
X if(tiles[i].removed == TRUE)
X continue;
X
X /* show the tile */
X
X wrastop(wn, tiles[i].image, 6, playing_area, COLS*9/8,
X 0, 0, tiles[i].x_pos, tiles[i].y_pos,
X TILE_W, TILE_H, SRCXOR, DSTSRC,
X (invert==1) ? patwhite : patblack);
X }
X wrastop(wn, playing_area, COLS*9/8, 0, 0, X_OFF1, Y_OFF1,
X X_OFF1, Y_OFF1, 14*TILE_X+TILE_W, 7*TILE_Y+TILE_H,
X SRCSRC, DSTSRC, 0);
X}
X
X/*
X * highlight a tile -- if already highlighted, turn it off
X */
X
Xpreview_tile(i)
Xint i;
X{
X wrastop(wn, 0, 0, 0, 0, 0, 0,
X tiles[i].x_pos+1, tiles[i].y_pos+1,
X TILE_X-1, TILE_Y-1, SRCPAT, DSTXOR, patwhite);
X}
X
X/*
X * beep at the user
X */
X
Xwindow_bell()
X{
X wprintf(wn, "\007");
X}
X
END_OF_FILE
if test 11675 -ne `wc -c <'mahjongg.c'`; then
echo shar: \"'mahjongg.c'\" unpacked with wrong size!
fi
# end of 'mahjongg.c'
fi
if test -f 'other.c' -a "${1}" != "-c" ; then
echo shar: Will not clobber existing file \"'other.c'\"
else
echo shar: Extracting \"'other.c'\" \(15142 characters\)
sed "s/^X//" >'other.c' <<'END_OF_FILE'
X/* array B contains a picture 48 pixels wide and 32 pixels high.
X for wrastop calls use srcwidth = 6, width = 48, and height = 32. */
Xunsigned short B[32][3] = {
X 0xffff, 0xffff, 0x07ff,
X 0x0001, 0x0000, 0x1c00,
X 0xfff9, 0xffff, 0x2cff,
X 0x0049, 0x0000, 0xd490,
X 0xfff9, 0xffff, 0xacff,
X 0x0249, 0x0000, 0x5492,
X 0x0149, 0x0000, 0xac94,
X 0x00c9, 0x0000, 0x5498,
X 0x0049, 0x0000, 0xac90,
X 0x0049, 0x0000, 0x5490,
X 0x0049, 0x0000, 0xac90,
X 0x0049, 0x003c, 0x5490,
X 0x0049, 0x004c, 0xac90,
X 0x0049, 0x004c, 0x5490,
X 0x0049, 0x007c, 0xac90,
X 0x0049, 0x008c, 0x5490,
X 0x0049, 0x008c, 0xac90,
X 0x0049, 0x007c, 0x5490,
X 0x0049, 0x0000, 0xac90,
X 0x0049, 0x0000, 0x5490,
X 0x0049, 0x0000, 0xac90,
X 0x00c9, 0x0000, 0x5498,
X 0x0149, 0x0000, 0xac94,
X 0x0249, 0x0000, 0x5492,
X 0xfff9, 0xffff, 0xacff,
X 0x0049, 0x0000, 0x5490,
X 0xfff9, 0xffff, 0xacff,
X 0x0001, 0x0000, 0x5400,
X 0xffff, 0xffff, 0xafff,
X 0xaaab, 0xaaaa, 0x5aaa,
X 0x555c, 0x5555, 0xb555,
X 0xaab0, 0xaaaa, 0xeaaa,
X};
X
X/* array C contains a picture 48 pixels wide and 32 pixels high.
X for wrastop calls use srcwidth = 6, width = 48, and height = 32. */
Xunsigned short C[32][3] = {
X 0xffff, 0xffff, 0x07ff,
X 0x0001, 0x0000, 0x1c00,
X 0x00f1, 0x0000, 0x2c00,
X 0x0119, 0x0000, 0xd400,
X 0x0019, 0x0080, 0xac00,
X 0x0019, 0x01c0, 0x5400,
X 0x0019, 0x03e0, 0xac00,
X 0x0119, 0x01c0, 0x5400,
X 0x38f1, 0xf1c0, 0xac00,
X 0xf801, 0xffff, 0x5403,
X 0xf801, 0x01c7, 0xac0f,
X 0x3c01, 0x01c0, 0x541e,
X 0x3c01, 0x01c0, 0xac3c,
X 0x3801, 0x01c0, 0x543e,
X 0x7001, 0x0ffc, 0xac37,
X 0xe001, 0xf9cf, 0x5407,
X 0xc001, 0xe1c1, 0xac03,
X 0x0001, 0x80c0, 0x5403,
X 0x0001, 0x00c0, 0xac00,
X 0x0001, 0x00c0, 0x5400,
X 0x0001, 0x00c0, 0xac00,
X 0x0001, 0x00c0, 0x5400,
X 0x0001, 0x00e0, 0xac00,
X 0x0001, 0x0060, 0x5400,
X 0x0001, 0x0070, 0xac00,
X 0x0001, 0x0038, 0x5400,
X 0x0001, 0x0000, 0xac00,
X 0x0001, 0x0000, 0x5400,
X 0xffff, 0xffff, 0xafff,
X 0xaaab, 0xaaaa, 0x5aaa,
X 0x555c, 0x5555, 0xb555,
X 0xaab0, 0xaaaa, 0xeaaa,
X};
X
X/* array F contains a picture 48 pixels wide and 32 pixels high.
X for wrastop calls use srcwidth = 6, width = 48, and height = 32. */
Xunsigned short F[32][3] = {
X 0xffff, 0xffff, 0x07ff,
X 0x0001, 0x0000, 0x1c00,
X 0x80fd, 0x0003, 0x2c00,
X 0x000d, 0x183f, 0xd400,
X 0x800d, 0x7067, 0xac00,
X 0xc63d, 0xe07c, 0x5400,
X 0xff0d, 0xc078, 0xac00,
X 0x3f8d, 0x6070, 0x5400,
X 0x000d, 0x30f8, 0xac00,
X 0x0001, 0x1d9c, 0x5400,
X 0x0001, 0x070e, 0xac0f,
X 0x8001, 0x0783, 0x541c,
X 0xe001, 0x0cc0, 0xac38,
X 0x3001, 0x18f0, 0x543f,
X 0x1c01, 0x30d8, 0xac1e,
X 0xc601, 0x70c1, 0x5400,
X 0x7301, 0xf8c0, 0xac01,
X 0x2001, 0x8ec7, 0x540f,
X 0xf801, 0x03c3, 0xac3e,
X 0x6c01, 0x00f0, 0x547c,
X 0x6001, 0xe0c0, 0xacf8,
X 0xf801, 0x3c60, 0x54e0,
X 0xcec1, 0x8e63, 0xac00,
X 0x67c1, 0x87fe, 0x5403,
X 0x7001, 0x0038, 0xac0f,
X 0x3b01, 0x001c, 0x541f,
X 0x1e01, 0x0000, 0xac1e,
X 0x0001, 0x0000, 0x5400,
X 0xffff, 0xffff, 0xafff,
X 0xaaab, 0xaaaa, 0x5aaa,
X 0x555c, 0x5555, 0xb555,
X 0xaab0, 0xaaaa, 0xeaaa,
X};
X
X/* array north contains a picture 48 pixels wide and 32 pixels high.
X for wrastop calls use srcwidth = 6, width = 48, and height = 32. */
Xunsigned short north[32][3] = {
X 0xffff, 0xffff, 0x07ff,
X 0x0001, 0x0000, 0x1c00,
X 0x0319, 0x0000, 0x2c00,
X 0x0339, 0x0000, 0xd400,
X 0x0379, 0x0000, 0xac00,
X 0x03d9, 0x1000, 0x5400,
X 0x0399, 0x1802, 0xac00,
X 0x0319, 0x3c07, 0x5400,
X 0xc319, 0x7f0f, 0xac00,
X 0x0001, 0x3c03, 0x5400,
X 0x0001, 0x1803, 0xac00,
X 0x1f01, 0x1803, 0x5400,
X 0x3e01, 0x1803, 0xac18,
X 0x3e01, 0x1803, 0x541c,
X 0x0001, 0x1803, 0xac1e,
X 0x0001, 0xf803, 0x540f,
X 0x0001, 0xf8f3, 0xac03,
X 0x8701, 0x181f, 0x5400,
X 0xff01, 0x1803, 0xac00,
X 0x3e01, 0x1803, 0x5400,
X 0x0001, 0x3803, 0xac1c,
X 0x8001, 0xf001, 0x541f,
X 0x8001, 0xe001, 0xac0f,
X 0x0001, 0x0000, 0x5400,
X 0x0001, 0x0000, 0xac00,
X 0x0001, 0x0000, 0x5400,
X 0x0001, 0x0000, 0xac00,
X 0x0001, 0x0000, 0x5400,
X 0xffff, 0xffff, 0xafff,
X 0xaaab, 0xaaaa, 0x5aaa,
X 0x555c, 0x5555, 0xb555,
X 0xaab0, 0xaaaa, 0xeaaa,
X};
X
X/* array east contains a picture 48 pixels wide and 32 pixels high.
X for wrastop calls use srcwidth = 6, width = 48, and height = 32. */
Xunsigned short east[32][3] = {
X 0xffff, 0xffff, 0x07ff,
X 0x0001, 0x0000, 0x1c00,
X 0x01f9, 0x000c, 0x2c00,
X 0x0019, 0x007c, 0xd400,
X 0x0019, 0x03f0, 0xac00,
X 0x0079, 0x01c0, 0x5400,
X 0x0019, 0x0040, 0xac00,
X 0x0019, 0x1c40, 0x5400,
X 0x01f9, 0x07f8, 0xac00,
X 0x0001, 0x005e, 0x5400,
X 0x0001, 0x0040, 0xac00,
X 0xc001, 0x0ffc, 0x5400,
X 0xc001, 0x3847, 0xac00,
X 0xc001, 0x6041, 0x5400,
X 0xc001, 0x63fc, 0xac00,
X 0xc001, 0x6047, 0x5400,
X 0xc001, 0x3040, 0xac00,
X 0x8001, 0x1fff, 0x5400,
X 0x0001, 0x0040, 0xac00,
X 0x0001, 0x0c4c, 0x5400,
X 0x0001, 0x3846, 0xac00,
X 0x8001, 0xe043, 0x5401,
X 0xf001, 0x0060, 0xac1f,
X 0x1e01, 0x00e0, 0x547c,
X 0x0001, 0x0040, 0xac60,
X 0x0001, 0x0000, 0x5400,
X 0x0001, 0x0000, 0xac00,
X 0x0001, 0x0000, 0x5400,
X 0xffff, 0xffff, 0xafff,
X 0xaaab, 0xaaaa, 0x5aaa,
X 0x555c, 0x5555, 0xb555,
X 0xaab0, 0xaaaa, 0xeaaa,
X};
X
X/* array south contains a picture 48 pixels wide and 32 pixels high.
X for wrastop calls use srcwidth = 6, width = 48, and height = 32. */
Xunsigned short south[32][3] = {
X 0xffff, 0xffff, 0x07ff,
X 0x0001, 0x0000, 0x1c00,
X 0x00f1, 0x0030, 0x2c00,
X 0x0199, 0x00e0, 0xd400,
X 0x0019, 0x03e0, 0xac00,
X 0x00f1, 0x01c0, 0x5400,
X 0x0181, 0x00c0, 0xac00,
X 0x0199, 0x00c0, 0x5400,
X 0x00f1, 0x3cc0, 0xac00,
X 0x0001, 0x07f8, 0x5400,
X 0x0001, 0x00ce, 0xac00,
X 0x0001, 0x00c0, 0x5400,
X 0xc001, 0xc0c0, 0xac00,
X 0x8001, 0xffe3, 0x5400,
X 0x0001, 0xe0fe, 0xac03,
X 0x8001, 0xa01f, 0x5407,
X 0xe001, 0x1e01, 0xac0e,
X 0x0001, 0x07f0, 0x541c,
X 0x0001, 0x60dc, 0xac38,
X 0x0001, 0x3cc0, 0x541c,
X 0x1801, 0x07c0, 0xac0e,
X 0x7001, 0xb1fc, 0x5407,
X 0xe001, 0xe0cf, 0xac01,
X 0xc001, 0x00c1, 0x5400,
X 0x0001, 0x0000, 0xac00,
X 0x0001, 0x0000, 0x5400,
X 0x0001, 0x0000, 0xac00,
X 0x0001, 0x0000, 0x5400,
X 0xffff, 0xffff, 0xafff,
X 0xaaab, 0xaaaa, 0x5aaa,
X 0x555c, 0x5555, 0xb555,
X 0xaab0, 0xaaaa, 0xeaaa,
X};
X
X/* array west contains a picture 48 pixels wide and 32 pixels high.
X for wrastop calls use srcwidth = 6, width = 48, and height = 32. */
Xunsigned short west[32][3] = {
X 0xffff, 0xffff, 0x07ff,
X 0x0001, 0x0000, 0x1c00,
X 0x0319, 0x0000, 0x2c00,
X 0x0359, 0x0000, 0xd400,
X 0x0359, 0x0000, 0xac00,
X 0x03f9, 0x0000, 0x5400,
X 0x03b9, 0xfc00, 0xac03,
X 0x0319, 0xffc0, 0x5407,
X 0x0209, 0x83fc, 0xac1f,
X 0xc001, 0x003f, 0x541e,
X 0xfc01, 0x0003, 0xac00,
X 0x3001, 0x3800, 0x5400,
X 0x0001, 0x7c03, 0xac00,
X 0x8001, 0x6601, 0x5400,
X 0x8001, 0x6301, 0xac00,
X 0x0001, 0x3303, 0x5400,
X 0x0001, 0x3fff, 0xac00,
X 0xe001, 0xf18f, 0x540f,
X 0x7001, 0x30dc, 0xac3e,
X 0x7001, 0x30d8, 0x5438,
X 0xe001, 0x1870, 0xac38,
X 0xc001, 0x1c61, 0x541c,
X 0x8001, 0xffe3, 0xac0f,
X 0x0001, 0xc000, 0x5407,
X 0x0001, 0x0000, 0xac00,
X 0x0001, 0x0000, 0x5400,
X 0x0001, 0x0000, 0xac00,
X 0x0001, 0x0000, 0x5400,
X 0xffff, 0xffff, 0xafff,
X 0xaaab, 0xaaaa, 0x5aaa,
X 0x555c, 0x5555, 0xb555,
X 0xaab0, 0xaaaa, 0xeaaa,
X};
X
X/* array plum contains a picture 48 pixels wide and 32 pixels high.
X for wrastop calls use srcwidth = 6, width = 48, and height = 32. */
Xunsigned short plum[32][3] = {
X 0xffff, 0xffff, 0x07ff,
X 0x0021, 0x0000, 0x1c00,
X 0x0031, 0x0100, 0x2c00,
X 0x0039, 0x0180, 0xd400,
X 0x001d, 0x0380, 0xac00,
X 0x1c05, 0x0700, 0x5400,
X 0x2799, 0xce00, 0xace6,
X 0x7479, 0x2c00, 0x5599,
X 0x8f8d, 0x7000, 0xad91,
X 0x74cd, 0xc800, 0x559f,
X 0xc64d, 0x89b8, 0xad22,
X 0x399d, 0x726f, 0x5426,
X 0xc019, 0xc264, 0xac1b,
X 0xe011, 0x17fe, 0x5400,
X 0x7001, 0x1492, 0xac00,
X 0x3801, 0x279c, 0x5400,
X 0x1801, 0x38f0, 0xac00,
X 0x0801, 0x5000, 0x5400,
X 0x0001, 0x6000, 0xac01,
X 0x0001, 0x8000, 0x5405,
X 0x0001, 0x0000, 0xac16,
X 0x2139, 0x0045, 0x5468,
X 0x2149, 0x006d, 0xac00,
X 0x2149, 0x0055, 0x5400,
X 0x2139, 0x0045, 0xac00,
X 0x2109, 0x0045, 0x5400,
X 0xcf09, 0x0044, 0xac00,
X 0x0001, 0x0000, 0x5400,
X 0xffff, 0xffff, 0xafff,
X 0xaaab, 0xaaaa, 0x5aaa,
X 0x555c, 0x5555, 0xb555,
X 0xaab0, 0xaaaa, 0xeaaa,
X};
X
X/* array orchid contains a picture 48 pixels wide and 32 pixels high.
X for wrastop calls use srcwidth = 6, width = 48, and height = 32. */
Xunsigned short orchid[32][3] = {
X 0xffff, 0xffff, 0x07ff,
X 0x0001, 0x0000, 0x1c00,
X 0x7301, 0xba4c, 0x2c03,
X 0x9481, 0x9252, 0xd404,
X 0x7481, 0x93c2, 0xac04,
X 0x5481, 0x9252, 0x5404,
X 0x9301, 0xba4c, 0xac03,
X 0x0001, 0x0000, 0x5400,
X 0x0001, 0x001c, 0xac06,
X 0x7021, 0x0022, 0x5403,
X 0x8861, 0x0022, 0xac01,
X 0x1041, 0x80f3, 0x543d,
X 0xe0c1, 0xc10e, 0xac07,
X 0x1181, 0xe21b, 0x5400,
X 0x8b21, 0xb9f1, 0xac30,
X 0x7661, 0xcc11, 0x541c,
X 0x0d81, 0xc613, 0xac06,
X 0x1319, 0x438d, 0x54e2,
X 0xa461, 0x60c1, 0xac38,
X 0xc8c1, 0x2060, 0x540c,
X 0xb301, 0x3031, 0xac06,
X 0x6601, 0x1813, 0x5403,
X 0x5801, 0xce12, 0xac01,
X 0x9001, 0x730c, 0x5400,
X 0x6001, 0x1900, 0xac00,
X 0x0001, 0x0000, 0x5400,
X 0x0001, 0x0000, 0xac00,
X 0x0001, 0x0000, 0x5400,
X 0xffff, 0xffff, 0xafff,
X 0xaaab, 0xaaaa, 0x5aaa,
X 0x555c, 0x5555, 0xb555,
X 0xaab0, 0xaaaa, 0xeaaa,
X};
X
X/* array bamboo contains a picture 48 pixels wide and 32 pixels high.
X for wrastop calls use srcwidth = 6, width = 48, and height = 32. */
Xunsigned short bamboo[32][3] = {
X 0xffff, 0xffff, 0x07ff,
X 0x0001, 0x0000, 0x1c00,
X 0x0001, 0x07e0, 0x2c00,
X 0x0c01, 0x1ffc, 0xd400,
X 0x1e01, 0x3ffe, 0xac00,
X 0x7e01, 0x7ffe, 0x5400,
X 0x7f01, 0xf3ff, 0xac00,
X 0x7f81, 0xe3ff, 0x5401,
X 0xbde1, 0x03bf, 0xac00,
X 0x9cf1, 0x031f, 0x55f0,
X 0xce01, 0x008b, 0xacfe,
X 0xe601, 0x0391, 0x543f,
X 0x0001, 0x8250, 0xac1f,
X 0x0001, 0x8420, 0x54fe,
X 0x8839, 0x8728, 0xadff,
X 0x9449, 0xc9cd, 0x55fe,
X 0xa279, 0x484a, 0xadba,
X 0xbe89, 0xc84a, 0x553b,
X 0xa289, 0x5e88, 0xac31,
X 0xa279, 0x7188, 0x5421,
X 0x0001, 0x2080, 0xac01,
X 0x1c39, 0xe087, 0x5400,
X 0xa249, 0x4088, 0xac00,
X 0xa279, 0x5c88, 0x5400,
X 0xa289, 0x6388, 0xac00,
X 0xa289, 0x0008, 0x5400,
X 0x1c79, 0x0007, 0xac00,
X 0x0001, 0x0000, 0x5400,
X 0xffff, 0xffff, 0xafff,
X 0xaaab, 0xaaaa, 0x5aaa,
X 0x555c, 0x5555, 0xb555,
X 0xaab0, 0xaaaa, 0xeaaa,
X};
X
X/* array mum contains a picture 48 pixels wide and 32 pixels high.
X for wrastop calls use srcwidth = 6, width = 48, and height = 32. */
Xunsigned short mum[32][3] = {
X 0xffff, 0xffff, 0x07ff,
X 0x0001, 0x0e30, 0x1c00,
X 0x0001, 0x067c, 0x2c38,
X 0xfc01, 0xf7fd, 0xd47e,
X 0x9601, 0x2bf2, 0xac3d,
X 0xad01, 0x45ee, 0x547b,
X 0x7981, 0x72ea, 0xacf5,
X 0x8e81, 0xaaed, 0x55f4,
X 0x9981, 0x46eb, 0xadeb,
X 0xe081, 0x62ec, 0x546a,
X 0x9981, 0x92c5, 0xac2d,
X 0x0f01, 0x8d87, 0x5474,
X 0xf801, 0x9c01, 0xacf6,
X 0x0001, 0xe000, 0x5473,
X 0x0001, 0x0000, 0xac00,
X 0x0001, 0x0000, 0x5400,
X 0x74b9, 0x2391, 0xac12,
X 0x9485, 0x504a, 0x5416,
X 0x7785, 0x8984, 0xadda,
X 0x5485, 0xfa04, 0x5412,
X 0x94b9, 0x89c4, 0xac12,
X 0x0001, 0x0000, 0x5400,
X 0xbe01, 0xa2f4, 0xad14,
X 0x8801, 0xb614, 0x55b4,
X 0x8801, 0xaa37, 0xad54,
X 0x8801, 0xaa14, 0x5554,
X 0x8801, 0x22f4, 0xad13,
X 0x0001, 0x0000, 0x5400,
X 0xffff, 0xffff, 0xafff,
X 0xaaab, 0xaaaa, 0x5aaa,
X 0x555c, 0x5555, 0xb555,
X 0xaab0, 0xaaaa, 0xeaaa,
X};
X
X/* array autumn contains a picture 48 pixels wide and 32 pixels high.
X for wrastop calls use srcwidth = 6, width = 48, and height = 32. */
Xunsigned short autumn[32][3] = {
X 0xffff, 0xffff, 0x07ff,
X 0x0001, 0x0000, 0x1c00,
X 0x0001, 0x0000, 0x2c00,
X 0x0001, 0x0000, 0xd400,
X 0xe001, 0x001f, 0xac00,
X 0x1e1d, 0x0008, 0x5400,
X 0x01e1, 0x0fc4, 0xac00,
X 0x0e41, 0x3038, 0x5400,
X 0x7081, 0xc000, 0xac00,
X 0x0081, 0xe007, 0x5401,
X 0x0081, 0x1038, 0xac00,
X 0x0881, 0xe380, 0x5400,
X 0x1441, 0x0c00, 0xac03,
X 0x1441, 0x6003, 0x5402,
X 0x35c1, 0x8187, 0xac05,
X 0x4601, 0x7245, 0x5407,
X 0x8401, 0x9c49, 0xac0f,
X 0x8001, 0x0851, 0x5418,
X 0x0001, 0x0060, 0xac00,
X 0x0001, 0x0000, 0x5400,
X 0x0001, 0x0000, 0xac00,
X 0x4441, 0x145f, 0x5445,
X 0x44a1, 0xb444, 0xac4d,
X 0x4511, 0x5444, 0x5455,
X 0x45f1, 0x5444, 0xac65,
X 0x4511, 0x1444, 0x5445,
X 0x3911, 0x1384, 0xac45,
X 0x0001, 0x0000, 0x5400,
X 0xffff, 0xffff, 0xafff,
X 0xaaab, 0xaaaa, 0x5aaa,
X 0x555c, 0x5555, 0xb555,
X 0xaab0, 0xaaaa, 0xeaaa,
X};
X
X/* array summer contains a picture 48 pixels wide and 32 pixels high.
X for wrastop calls use srcwidth = 6, width = 48, and height = 32. */
Xunsigned short summer[32][3] = {
X 0xffff, 0xffff, 0x07ff,
X 0xe001, 0x001f, 0x1c00,
X 0xc001, 0xf870, 0x2c01,
X 0x1e01, 0x8cc3, 0xd400,
X 0x6181, 0x8286, 0xac00,
X 0xe0c1, 0x62fe, 0x5418,
X 0x9e41, 0x9383, 0xac1f,
X 0xf3e1, 0xc600, 0x5411,
X 0x6061, 0x7c00, 0xac18,
X 0x3f01, 0x0800, 0x540c,
X 0x21c1, 0x0800, 0xac07,
X 0x3c61, 0xf800, 0x5401,
X 0x6631, 0x1c00, 0xac00,
X 0xf311, 0xe600, 0x5401,
X 0x9991, 0x0783, 0xac07,
X 0x88d1, 0x0cff, 0x541c,
X 0x4871, 0x38c4, 0xac07,
X 0x9861, 0xe38c, 0x5401,
X 0xb001, 0x0639, 0xac00,
X 0xe001, 0x1fe3, 0x5400,
X 0x0001, 0x0000, 0xac00,
X 0x44f1, 0xf451, 0x547d,
X 0x4509, 0x16db, 0xac84,
X 0x4431, 0x7555, 0x5484,
X 0x44c1, 0x1555, 0xac7c,
X 0x4509, 0x1451, 0x5464,
X 0x38f1, 0xf451, 0xacc5,
X 0x0001, 0x0000, 0x5400,
X 0xffff, 0xffff, 0xafff,
X 0xaaab, 0xaaaa, 0x5aaa,
X 0x555c, 0x5555, 0xb555,
X 0xaab0, 0xaaaa, 0xeaaa,
X};
X
X/* array spring contains a picture 48 pixels wide and 32 pixels high.
X for wrastop calls use srcwidth = 6, width = 48, and height = 32. */
Xunsigned short spring[32][3] = {
X 0xffff, 0xffff, 0x07ff,
X 0x0001, 0x0000, 0x1c00,
X 0x0001, 0x006e, 0x2c10,
X 0x0001, 0x0033, 0xd418,
X 0x0001, 0xc011, 0xac0d,
X 0x0001, 0x6009, 0x5406,
X 0x0001, 0x200e, 0xac01,
X 0x3801, 0xe004, 0x5400,
X 0xcc01, 0x3782, 0xacdc,
X 0x8401, 0x1841, 0x5466,
X 0x4801, 0x0640, 0xac32,
X 0x6001, 0x0180, 0x541e,
X 0x1bc1, 0x1cef, 0xac07,
X 0x8c61, 0xe238, 0x5401,
X 0x8641, 0x710e, 0xac00,
X 0x0301, 0x0d01, 0x5400,
X 0xc0c1, 0x0300, 0xac00,
X 0x3861, 0x00c0, 0x5400,
X 0x0c01, 0x003c, 0xac00,
X 0x8001, 0x0007, 0x5400,
X 0x0001, 0x0000, 0xac00,
X 0x79e1, 0x173e, 0x5439,
X 0x8a11, 0x3242, 0xac45,
X 0x8861, 0x5242, 0x5405,
X 0x7981, 0x923e, 0xac65,
X 0x0a11, 0x1232, 0x5445,
X 0x09e1, 0x1762, 0xac39,
X 0x0001, 0x0000, 0x5400,
X 0xffff, 0xffff, 0xafff,
X 0xaaab, 0xaaaa, 0x5aaa,
X 0x555c, 0x5555, 0xb555,
X 0xaab0, 0xaaaa, 0xeaaa,
X};
X
X/* array winter contains a picture 48 pixels wide and 32 pixels high.
X for wrastop calls use srcwidth = 6, width = 48, and height = 32. */
Xunsigned short winter[32][3] = {
X 0xffff, 0xffff, 0x07ff,
X 0x0001, 0x0070, 0x1c00,
X 0x0001, 0x0070, 0x2c00,
X 0x1c01, 0xc421, 0xd401,
X 0x1c01, 0xc2fa, 0xac01,
X 0x3001, 0x6525, 0x5400,
X 0xc001, 0x19fc, 0xac00,
X 0x2c01, 0xa623, 0x5401,
X 0x7001, 0x7525, 0xac00,
X 0x9001, 0x48f8, 0x5400,
X 0xffc1, 0xffff, 0xac1f,
X 0x91c1, 0x48f8, 0x541c,
X 0x7001, 0x7525, 0xac00,
X 0x2c01, 0xa623, 0x5401,
X 0xc001, 0x19fc, 0xac00,
X 0x3001, 0x6525, 0x5400,
X 0x1c01, 0xc2fa, 0xac01,
X 0x1c01, 0xc421, 0x5401,
X 0x0001, 0x0070, 0xac00,
X 0x0001, 0x0070, 0x5400,
X 0x0001, 0x0000, 0xac00,
X 0x7d11, 0xf7d1, 0x543d,
X 0x1111, 0x1113, 0xac44,
X 0x1151, 0x7115, 0x5444,
X 0x1151, 0x1119, 0xac3c,
X 0x11b1, 0x1111, 0x5424,
X 0x7d11, 0xf111, 0xac45,
X 0x0001, 0x0000, 0x5400,
X 0xffff, 0xffff, 0xafff,
X 0xaaab, 0xaaaa, 0x5aaa,
X 0x555c, 0x5555, 0xb555,
X 0xaab0, 0xaaaa, 0xeaaa,
X};
END_OF_FILE
if test 15142 -ne `wc -c <'other.c'`; then
echo shar: \"'other.c'\" unpacked with wrong size!
fi
# end of 'other.c'
fi
echo shar: End of archive 2 \(of 2\).
cp /dev/null ark2isdone
MISSING=""
for I in 1 2 ; do
if test ! -f ark${I}isdone ; then
MISSING="${MISSING} ${I}"
fi
done
if test "${MISSING}" = "" ; then
echo You have unpacked both archives.
rm -f ark[1-9]isdone
else
echo You still need to unpack the following archives:
echo " " ${MISSING}
fi
## End of shell archive.
exit 0
--
David H. Brierley
Home: dave@galaxia.newport.ri.us; Work: dhb@quahog.ssd.ray.com
Send comp.sources.3b1 submissions to comp-sources-3b1@galaxia.newport.ri.us
%% Can I be excused, my brain is full. **