HDTenEightyP/NetNews huggingface dataset:
From: sang@cm.deakin.OZ.AU (Shane Hyde)
Newsgroups: rec.games.programmer
Subject: X11 game in alt.sources
Date: 10 Nov 1992 06:36:48 GMT
Organization: Deakin University, Geelong, Australia
Distribution: world
NNTP-Posting-Host: aragorn.cm.deakin.oz.au


Howdy,
	I have just placed a game in alt.sources, for all the r.g.p people
to try out for me and send any comments regarding anything about it.

The game is not finished, but it is well and truly playable.

For the people with X11 terms out there, some comments would be great.  
(Good, bad, flames, it doesn't matter)  (N.B. xmpb requires 32 bit ints)

Try it out and tell me what you like/hate -

		sang@cm.deakin.oz.au
or		ddp@cm.deakin.oz.au

Seeya,
Shane(sang@cm.deakin.oz.au)
--
Shane Hyde (sang@cm.deakin.oz.au)|'Tell me, who's the real patriots, the Archie
Dept. of Computing/Mathematics   |Bunker slobs waving flags, or the people with
Deakin University                |the guts to work for some real change?' -
Geelong Vic 3217                 |                 Jello Biafra.
Newsgroups: rec.games.programmer
From: K1N2 <K1N2@UNB.CA>
Subject: Text Mode & ANSI Animation?
Organization: The University of New Brunswick
Date: Sun, 8 Nov 1992 21:16:40 GMT

I've been trying to write a computer movie, and I got interested in
the idea of text animation when I saw my VGA card had a mode for
80 x 50 text characters.  I thought that if I used colored spaces
placed on the screen, using (say) the BASIC COLOR and LOCATE/PRINT
statements as a replacement for a 'putpixel' routine, I could
create a very fast-moving if somewhat cheap animated screen.

However, I tried doing this and it seems disappointingly slow. Of
course this is probably because I was using the QBASIC interpreter
that comes with DOS; but then again, this interpreter was on a
386/33 PC.  Is it feasible to use text mode animation in the way I
described, with some other language, perhaps?  Would it be in
general faster than typical pixel-based animation?

I also heard about 'ANSI', which seems to be an improved form of
text mode.  Would this make for good animation instead?

What I was planning, BTW; a simple set of numbers would act as a
code for a 'text bitmap', which could be placed on the screen at
various places.  0-15 would represent a space of a certain color,
while 16 would be transparent; in the animation program, I would
account for a larger, background text bitmap image that had a
special place in the program's data arrays, and other bitmaps would
be placed over this, being replaced by the background's color space
data when erased.  The '16-transparent' would represent a space
which would have the same data as the background for that position
on the screen.

Anyhow, could someone please give any advice or comments on how I
could do this quickly and smoothly?

-Aphoriel/Kinsman
From: cyberman@toz.buffalo.ny.us (Cyberman)
Newsgroups: rec.games.programmer
Subject: Re: advice needed for fas
Date: 13 Nov 92 04:22:15 GMT
X-Maildoor: WaflineMail 1.00r


    Russ Trotter entitled a message as 'Re: advice needed for fas',
   on the 11-11-92  16:10 to All.
 RT> I hate to jump on this seemingly runaway train but.... 

 RT> In one of my classes, I remember the teacher saying that it
 RT> had been proven that O(n log n) was the best one could do
 RT> for _comparison_ based sorting...  Is this a more correct assertion?

 RT> I don't know much (at all :) ) about Radix sort  (only how to spell it
 RT> :) ) so I can't be sure if it disproves the statement above.


 RT> I've seen posts flying back and forth about this and quite frankly
 RT> I'm getting a bit confused...

    Let me help SORT this out.  Basically some algorythmes are
    faster at different sort sizes.  This is because O() notation
    ignores constants IE minimume setup/execution times.
    therefore lets say we were sorting a 12 item array.

    Lets say Quick sort ACTUAL speed is
    36.43*(n log n)
    and bubble sort is
    5.75*(n*n)

    for 12 items the bubble sort comes out around
    829

    quick sort would come out
    1089

    now which one is faster?

    Quick sort is recursive.  This means though it may have the
    fewest comparisons it also has to contend with stack
    overhead.  Each new partition requires 2 new pointers be
    allocated on the stack PLUS any local data.  This ussually
    takes a LOT longer than a comparison (unless sorting
    strings).  In this case we are dealing with numerical data
    and a comparison here is much quicker than the added stack
    operations.

    There are a number of criteria that must be specified in a time
    critical application before using a particular algorythm.

    Here are some I've pointed out.

    how many comparisons and how long is each comparison?
    how many recursions and local data operations?
    how long does it take to "move" data? (swaping pointers or
        swaping values)
    
    these must be all relative to the NUMBER of items sorted.  In
    some cases there will be a large difference.  In others there
    will be virtually none.

    In this persons case he want a VERY fast algorythm and likely
    for no more than 20 items.  This is also frequently sorted
    data so it is very likely to be nearly sorted already.  All
    of these hint at using a simpler sort that can check for
    everything being sorted before going into coniptions.  I'm
    not sure if Qsort does this (been a while since I've needed
    to sort things).

                Stephen Cyberman@Toz.Buffalo.NY.US
             Mangled on Thu  11-12-1992  at 20:25:15

... This tagline is not taxed ,... YET !
--- Blue Wave/QWK v2.10
                                                  
Newsgroups: rec.games.programmer
From: jrivera@den.mmc.com (Joseph Rivera)
Subject: Text Adventure Languages
Originator: jrivera@kola
Organization: Martin Marietta Astronautics, Denver
Date: Wed, 11 Nov 1992 22:06:08 GMT

I am interested in writing a text based adventure game and I would like
some opinions on the different adventure systems (i.e. ADL vs ADVSYS).
Flexibility and ease of use are my main concerns.

Thanks
Joe Rivera
jrivera@evans.den.mmc.com
From: jas37876@uxa.cso.uiuc.edu (John A. Slagel)
Newsgroups: rec.games.programmer
Subject: Re: Code for loading
Date: 5 Nov 92 01:30:26 GMT
Article-I.D.: news.Bx7yus.8CA
Organization: University of Illinois at Urbana

colin.buckley@rose.com (colin buckley) writes:


>Date Entered: 11-04-92 15:38

>  JNC  @@Even
>  MOVSB
>@@Even:
>  REP MOVSW

>  is quicker on my computer, and because the possible odd byte is moved
>first, we get even 16-bit moves.  I assume anyways.  It was faster in large
 
    No, the odd/even for 16-bit moves is determined by where the
    first byte starts in memory, not whether the length is odd or even.
    REP MOVSW will always move an even number of bytes.

>.----------------------------------------------------.
>| Colin Buckley -- 486 Powered (Packing Extra Socks) |
                    ^^^ This is why its faster on yours... On 386 or 286,
			that isn't the case.

    There are three methods of doing fast moves:   
    (1)                (2)              (3) (Assumes top 1/2 of ECX is 0)
    shr cx,1           shr  cx, 1        ror   ecx, 2
    rep movsw          rep  movsw        rep   movsd
    adc cx, cx         jnc  notodd       rol   ecx, 2
    rep movsb          movsb             rep   movsb
                       notodd:

     Speed ordering:   486:  Fastest=3
			     Medium=2
			     Slow=1
                       386:  Fastest=3
			     Medium=1
			     Slow=2
                       286:  Fastest=1
			     Slow=2
			     (3 not possible)

    Explanation:
     3 is obviously the fastest if you have a 32-bit data bus. It
     will move 4 bytes at a time, with a few byte moves at the end to 
     clean up.

     Item 1 is faster than 2 because if the length is even, it doesn't
     branch which saves some cycles and won't blow the prefetch queue.
     (Jumps are BAD!)  If the length is odd, the REP will cause a slowdown,
     but if the lengths are equal odd and even, 1 will tend to be faster.
     However, the 486 will do method #2 faster 'cause its weird.          

     I use item #1 because using jumps in inline assembler tend to be
     a pain in the rear sometimes. Also, I have a 386 so its faster on mine.


-- 
------------------------------------------------------------------------
  John A. Slagel, email: jas37876@uxa.cso.uiuc.edu
Newsgroups: rec.games.programmer
From: hrjoist@immd4.informatik.uni-erlangen.de (Holger Joist)
Subject: Re: Card Shuffling
Organization: CSD., University of Erlangen, Germany
Date: Thu, 12 Nov 1992 15:47:12 GMT

HeroSoftware@cup.portal.com (Bits of Magic) writes:

>A quick and dirty way is:

>	Card	deck[DECKSIZE];

>	for (i=0;i<DECKSIZE;i++)
>		deck[i] = i;

>	for (i=0;i<SWAPS;i++) {
>		firstcard = random(DECKSIZE);
>		secondcard = random(DECKSIZE);
>		temp = deck[firstcard];
>		deck[firstcard] = deck[secondcard];
>		deck[secondcard] = temp;
>	}

>where your Card values run from 0 to DECKSIZE (say 52 or 54), random(N)
>returns a random integer in the range 0 to N-1 (inclusive), and SWAPS
>is (as I recall from a project many years ago) at least about 100.

The problem with this method is that the exchanges can wipe out each other.

I think a better way is:

/* initialize */
for (i = 0; i < DECKSIZE; i++)
	deck[i] = i;

/* choose one element randomly,       */
/* exchange it with the last element, */
/* repeat with the rest of the deck   */

for (i = DECKSIZE - 1; i >= 0; i--)
{
	rnd = random(i + 1);
	x = deck[i];
	deck[i] = deck[rnd];
	deck[rnd] = x;
}


Using that  method  you  get  a  perfect  permutation.  And  this
alorithm  works  for  every  DECKSIZE  (Asuming  random() is good
enough) in only DECKSIZE loops.


Holger
-- 
Snail: Holger Joist, Neue Strasse 29, 8520 Erlangen, Germany
Email: hrjoist@immd4.informatik.uni-erlangen.de
From: tal691@huxley.anu.edu.au (Tonio Loewald)
Newsgroups: rec.games.programmer
Subject: Re: Software Pinball Machine
Date: 11 Nov 92 03:10:53 GMT
Organization: Australian National University
NNTP-Posting-Host: 150.203.2.12

mgemmel@cs.vu.nl (Martin Gemmel) writes:

>Writing a pinball simulator is what I've been thinking of for a long
>time, too.

>f110019@hamlet.ucdavis.edu (Julian Burger) writes:

>} In other words, you would have a pinball-table description language which
>} would be parsed and a table created from it.

>The idea sounds good, but for the moment the most important question
>is just how to calculate ball motions and the effects of the various
>objects on the ball(s). I think a feature to read custom table
>descriptions could easily double the code, as you would have to
>precompute lots of data for each object (no doubt involving floating
>point operations).

>} For example:
>} bumper (50,30) {  ; center position (virtual coordinates) in parens
>} 	size 20			; relative to something
>} 	force 50			; kicker force, or negative if absorbs energy
>} 	points 50
>} 	...
>} 	etc

>I'm sure you don't want to have only bumpers, but how do you specify
>objects other than bumpers?

>Martin

My 2 cents worth:

Do the whole thing using an OOP language. Start with a base class:
CPost -- a simple object that collides with things as a point
source. Its behaviour serves as a template for any thing in the
machine (including the flippers and the spring-launcher).

A couple of obvious methods come to mind:
CPost.affectball(position,velocity,spin)
CPost.ignoreMe(position):boolean

And for construction:
CPost.placeMe
CPost.rotateMe
and so on...

The idea of the latter is to provide as rapid a method of
ignoring components as possible.

And if the ball has a CONTEXT as well as a position, velocity,
and spin, you can easily handle multi-level machines.

The best thing about all this is that it makes writing a
graphical construction utility a lot easier. You might
even write the construction utility using OOP and design it
to optimize out the OOP overhead during play.

Or you could write the whole thing in C++ and explicitly
call all the inherited functions, thus eliminating the OOP
overhead.


Tonio Loewald

-- 
Tonio Loewald            | Ph  06 290 1594 | 13 Sabine Cl. Garran
tal691@huxley.anu.edu.au | Fax 06 290 1595 | ACT 2605   AUSTRALIA
"You can lie/You can cry/For all the good it'll do you, you can
die/But when it's done/And the police come/And they lay you down
Newsgroups: rec.games.programmer
From: ematias@csri.toronto.edu (Ummm... me!)
Subject: Re: Text Mode & ANSI Animation?
Organization: CSRI, University of Toronto
Date: 9 Nov 92 05:41:29 GMT

In article <08NOV92.18660100.0176@UNBVM1.CSD.UNB.CA> K1N2 <K1N2@UNB.CA> writes:
>I've been trying to write a computer movie, and I got interested in
>the idea of text animation when I saw my VGA card had a mode for
>80 x 50 text characters.  I thought that if I used colored spaces
>placed on the screen, using (say) the BASIC COLOR and LOCATE/PRINT
>statements as a replacement for a 'putpixel' routine, I could
>create a very fast-moving if somewhat cheap animated screen.
>
>However, I tried doing this and it seems disappointingly slow. Of
>course this is probably because I was using the QBASIC interpreter
>that comes with DOS; but then again, this interpreter was on a
>386/33 PC.  Is it feasible to use text mode animation in the way I
>described, with some other language, perhaps?  Would it be in
>general faster than typical pixel-based animation?
>
>I also heard about 'ANSI', which seems to be an improved form of
>text mode.  Would this make for good animation instead?
>
>Anyhow, could someone please give any advice or comments on how I
>could do this quickly and smoothly?

   I wrote some ANSI animation programs (for BBS ads) in 'C' a number of
years ago, and they flew on the lowly XT I had at the time, so speed isn't
really a problem.  :-)
   All you really need is a Pascal or C compiler (plus a limited knowledge
of either of these languages, of course), and an ANSI-drawing program.  The
drawing program I used was called "TheDraw", and it's probably your best
bet.  Any semi-recent version of it will include a README file which gives
an in-depth explanation of how to use ANSI text "bitmaps" (arrays) in C or
Pascal programs, so I'd suggest getting a copy of this program from an FTP
site or BBS.


Hope this helps...

-Mark-
Newsgroups: rec.games.programmer
From: (jim )
Subject: Re: Game Lib for TP6.0 Multi Maps/Paralax
Reply-To: etljmme@etlxd10h.etlxd
Organization: Ericsson
Date: Thu, 5 Nov 1992 14:05:18 GMT


Can anyone uuencode this game10.zip and post it up?  I can't access remote ftp sites
because of our company rules!!

Thanks in advance to any charitable soul!

Jim.
Newsgroups: rec.games.programmer
From: ramsays@access.digex.com (Scott Ramsay)
Subject: Re: Software Pinball Machine
Organization: Express Access Online Communications, Greenbelt, MD USA
Date: Fri, 6 Nov 1992 15:55:46 GMT

In article <1992Nov5.135235.7388@meiko.com> gordon@meiko.com (Gordon Henderson) writes:
>
>Does anyone remember the pinball games that ran on the Apple ][ ???
>(1MHz 6502 for you who don't rmember the good old days!) There
>were at least two of them, and there was even a pinball creation game
>system! (Author Bill Budge, but I may be wrong - it's been a *long* time!)

  Oh yeah,  Night Mission pinball!  I HAD a apple ][+ that was a great
 game.  I always wondered how they calc. the ball angles when it hits
  something.  Does anybody have any Ideas?  It was fast on my Apple,
 I even had Night Mission pinball for IBM.  Its an old CGA game that
  is blinding fast even on my old 10mhz machine.

>--
>  Gordon Henderson

  I would love to write a pinball game. But I do not know any fast
 calcuations for ball reflections.  Help.

  Scott Ramsay
  ramsays@access.digex.com

Newsgroups: rec.games.programmer
From: ramsays@access.digex.com (Scott Ramsay)
Subject: Re: Game Lib for TP6.0 Multi Maps/Paralax
Organization: Express Access Online Communications, Greenbelt, MD USA
Date: Fri, 6 Nov 1992 16:04:44 GMT

HI Jim,

In article <1992Nov5.140518.9761@ericsson.se> etljmme@etlxd10h.etlxd writes:
>
>Can anyone uuencode this game10.zip and post it up?  I can't access remote ftp sites
>because of our company rules!!
>
  My GameTP10.zip lib is about 189K. uuencoded will be even larger.  It
would be a very large post. Anyone who wants it that does not have ftp access
can e-mail me a message and I'll send it via e-mail (uuencoded).
 
>Thanks in advance to any charitable soul!
>
>Jim.
 
  Scott Ramsay
  ramsays@access.digex.com

Newsgroups: rec.games.programmer
From: gordon@meiko.com (Gordon Henderson)
Subject: Re: Software Pinball Machine
Organization: Meiko Scientific Corp.
Date: Thu, 5 Nov 1992 13:52:35 GMT

In article <1992Nov2.204624.24267@u.washington.edu> goble@hardy.u.washington.edu (Brian Goble) writes:
>
>I have programmed many arcade style games but never anything like a
>pinball machine.  It seems very challenging and I am interested in hearing
>what others have done or how they might go about it.

Does anyone remember the pinball games that ran on the Apple ][ ???
(1MHz 6502 for you who don't rmember the good old days!) There
were at least two of them, and there was even a pinball creation game
system! (Author Bill Budge, but I may be wrong - it's been a *long* time!)
 
It had a basic board area, and an area where you could drag the little
icons representing bumpers, pushers, flags, flippers and whatnot into
the board using a joystick! You could also draw scenery onto the board.
I seem to recall that it was quite fast too!
 
All this was ... Oh ... 8 years ago ...
 
--
  Gordon Henderson
From: stigo@ifi.uio.no (Stig Arne Olsen)
Newsgroups: rec.games.programmer
Subject: Re: Software Pinball Machine
Date: 5 Nov 92 23:06:23 GMT
Organization: Dept. of Informatics, University of Oslo, Norway
Originator: stigo@holmenkollen.ifi.uio.no


In article <Nov05.172201.77839@yuma.ACNS.ColoState.EDU>, millerje@CS.ColoState.EDU (Jeff Miller) writes:
> In article <1992Nov5.155947.29934@mnemosyne.cs.du.edu> vputz@nyx.cs.du.edu (Victor Putz) writes:
> >
> there was also David's Midnight Magic.  AMIGA has an *amazing* pinball
> game called "Pinball Dreams"...it makes me want to buy an amiga just to
> play it.

Pinball Dreams just got a follow-up, called Pinball Fantasies. This is the best
electronic pinball I've ever played (my previous pinball favourite was the
good, old David's MM).  This game was in fact coded by some swedish demo-makers,
and the ball moves very realistically.

For the other amiga owners out there, I can tell that I have made a pac-man like
game in 100% assembly that I have released with source to some sites. It's called
snackman.lzh and snacksrc.lzh (the source). It could need some more work, but it's
playable as it is. Check out amiga.physik.unizh.ch or ftp.ludd.luth.se.
>  _____________________________________________________________________________
> |                                                                             |
> | "Nuke the unborn gay whales!" |  millerje@cs.colostate.edu  |  Jeff Miller  |
> |_____________________________________________________________________________|

-- 
Stig A. Olsen  |  stigo@ifi.uio.no  |  "Ja til EF"
Newsgroups: rec.games.programmer
From: jas37876@uxa.cso.uiuc.edu (John A. Slagel)
Subject: Re: Advice needed for fastest sort algorthm
Organization: University of Illinois at Urbana
Date: Sat, 7 Nov 1992 20:46:40 GMT

kds@phy.duke.edu (Stokes Kevin) writes:


>  This new project has objects much closer to the observer, and I fear
>there may be significant changes in the list order between every sort.
>Which sorting algorthm is the most time efficient?

   Definately the quick sort.  Its even built into ANSI C specs, so it
   should be easy to implement.  Look up quicksort in your C manual. If
   I remember right, bubble sort works in O(n*n) and quicksort works in
   O(n*log n).

   In other words, if you're sorting n objects, QuickSort takes "on the Order
   of" n*log n steps, while bubble sort takes "on the order of" n*n steps.

   If you happen to have Microsoft C, check out the sortdemo program that
   comes with it as a sample program.  It graphically show you the difference
   between the sorting methods.

-- 
------------------------------------------------------------------------
  John A. Slagel, email: jas37876@uxa.cso.uiuc.edu
Newsgroups: rec.games.programmer
From: millerje@CS.ColoState.EDU (Jeff Miller)
Subject: Re: Software Pinball Machine
Date: Thu, 05 Nov 1992 17:22:01 GMT
Organization: Colorado State University, Computer Science Department

In article <1992Nov5.155947.29934@mnemosyne.cs.du.edu> vputz@nyx.cs.du.edu (Victor Putz) writes:
>
>
>Yes, the software was "Bill Budge's Pinball Construction Set" or some
>such.  it was a very capable piece of software (even on the apple II), and
>I haven't seen anything that could compare to it in a while.
>
>-->Vputz
>

there was also David's Midnight Magic.  AMIGA has an *amazing* pinball
game called "Pinball Dreams"...it makes me want to buy an amiga just to
play it.

BTW:  A long time back (almost 10 years ago?) a magazine had an article on
programming a Pinball simulation.. I would have saved it if I wasn't so
overwhelmed by the Physics involved (I was about 14 years old!) - I just
wish I could remember where that was

-- 
 _____________________________________________________________________________
|                                                                             |
| "Nuke the unborn gay whales!" |  millerje@cs.colostate.edu  |  Jeff Miller  |
|_____________________________________________________________________________|
Newsgroups: rec.games.programmer
From: libh@Jane.UH.EDU
Subject: Re: Advice needed for fastest sort algorthm
Reply-To: libh@Jane.UH.EDU
Organization: University of Houston
Date: Sun, 8 Nov 1992 01:26:28 GMT

In article <BxD5pt.DyI@news.cso.uiuc.edu>, jas37876@uxa.cso.uiuc.edu (John A. Slagel) writes:
>kds@phy.duke.edu (Stokes Kevin) writes:
>
>
>>  This new project has objects much closer to the observer, and I fear
>>there may be significant changes in the list order between every sort.
>>Which sorting algorthm is the most time efficient?
>
>   Definately the quick sort.  Its even built into ANSI C specs, so it
>   should be easy to implement.  Look up quicksort in your C manual. If
>   I remember right, bubble sort works in O(n*n) and quicksort works in
>   O(n*log n).
>
>   In other words, if you're sorting n objects, QuickSort takes "on the Order
>   of" n*log n steps, while bubble sort takes "on the order of" n*n steps.
>
  The bubble sort takes N! (# factorial) steps, rather than N*N steps.  A BIG
difference.  But as pointed out, the quicksort is the easiest to implement
since it is in C libraries.  Why reinvent the wheel.  If that isn't quick
enough then I would check out Knuth's 'Art of Programming' Vol. 3 since it is
pretty much only about sorting.

********************************************************************************
*                       | What do I see?                                       *
*                       | I see time as it affects all things . . .            *
*   John White          | Human flesh withers and dies before my eyes. .       *
*                       | Flowers bloom only to fade . . .                     *
*   Libh@Jetson.uh.edu  | Trees drop green leaves, never to regain them        *
*                       | In my sight. . .it is always winter. . .always night *
*                       |                                     -- Raistlin --   *
********************************************************************************

Newsgroups: rec.games.programmer
From: carld@ms.uky.edu (Carl Lafferty)
Subject: vga mode 13
Keywords: vga animate
Summary: how to I page flip
Date: Fri, 13 Nov 1992 20:29:04 GMT
Organization: University Of Kentucky, Dept. of Math Sciences

I have been trying to monitor quietly for some time now as a friend
gives me the articles to this group to save my phone bill..

Anyway.  I was wondering if anyone can tell me how to page flip using
mode $13 on the IBM vga compatibles.  Any help will be appreciated.  

Either Post or E-Mail will be acceptable terms for reply.

Carl Lafferty