Jump to content

SGI Dogfight

Add links
From Wikipedia, the free encyclopedia

This is an old revision of this page, as edited by AstridRedfern (talk | contribs) at 22:17, 20 August 2022 (In-game physics - stall and spin). The present address (URL) is a permanent link to this revision, which may differ significantly from the current revision.

For other use of term, see Dogfight (disambiguation).
Dogfight
The view from inside of a cockpit
Developer(s)Gary Tarolli
Publisher(s)Silicon Graphics Incorporated
Platform(s)SGI Workstations
Release1985 as a free demo
Genre(s)Flight Simulator
Mode(s)Single Player, Multiplayer

Dogfight is a demonstration program initially written by Gary Tarolli (later founder of 3dfx) at Silicon Graphics, Inc in the summer of 1983.[1][2][3] It represents landmarks in two key areas of Internet development: games and multicasting, and notable advancement in creating rendered virtual environments.[citation needed]

Overview

Dogfight might more properly be referred to as three programs, flight, dog, and shadow. Flight is a flight simulator, dog is an air combat game in which multiple people use the flight interface to control their aircraft, and shadow is an observation program that allows a user to see what a user of either dog or flight sees.[4][5]

dog and shadow could also be run in "airshow mode", using the -i and -o command-line switches. With -o, the path taken by the plane would be saved to a file instead of being broadcast to the network. With -i, the user could specify a file containg a saved flightpath of this sort, and it would be displayed. Missiles fired by a plane in this mode would not affect planes in non-airshow mode. The intention was for the user to be able to record the paths of several aircraft, and then, by replaying them simultaneously, to be able to display complex aerial formations with multiple planes.[4]

The following planes were available:[citation needed]

Later versions added:[citation needed]

History

Flight was written in the summer of 1983 by Gary Tarolli, as a demo for SGI workstations.[2][3] It was inspired by the Blue Angels airshows at Moffett Field, across the street from SGI's original headquarters.[2][6]

In 1984, networking capabilities began to be added. Initially, two workstations were connected by a serial cable. This allowed about 7 frames per second and 500 polygons per second on a machine with a Motorola 68000 CPU capable of approximately 1 MIPS. By SIGGRAPH 1984, XNS multicast support was added, allowing play over an Ethernet network.[2][3] After the event, the networked version of Flight was distributed on all SGI workstations.[3]

Probably in early 1985, dog was created,[2][3] and dog and flight were shipped as demonstration software included with SGI workstations. Message packets were transmitted at frame rate, and the number of players was capped due to bandwidth limitations, although sources differ as to whether this cap was 10 players[6] or a value in the tens of players.[2] Due to the network congestion resulting from so many packets being transmitted at frame rate, many system administrators removed dogfight from newly installed systems in order to prevent abuse of resources.[2] Other sysadmins limited play to restricted off-peak hours.[citation needed]

Dead reckoning was later added, to reduce the amount of data that needed to be transmitted.[6]

In 1986, UDP broadcast protocol capability was added (using port 5130).[7][8][9] Information was transmitted via broadcast packets and at frame rate, meaning that the program made intensive use of network resources and even a small number of players was capable of saturating an Ethernet. So while it was probably the first game to use the Internet Protocol Suite, the game could not pass through a router, and thus could not be played across the Internet itself.[citation needed]

By 1988, with the introduction of SGI's 4D series of machines, Dogfight had forked, with one version running on most SGI machines of the time (3000 series, 4DxxG's, Personal IRIS, GT, GTX) and another for use only on the higher-end GT, GTX and VGX machines.[4] These could interoperate, with both versions playing in the same game. The 4D/20 was observed to run dog at around 12 frames per second, while the faster 4D/70 would be capable of 20-25 fps. The other version was observed to run on a GT at around 15 frames/second.[10] In the Irix 6.5 documentation, it was noted that the Boeing 727 and F-14 were not available to choose as planes in the normal version of the software, but were present in the GT/GTX/VGX version.[4]

SGI would supply the source code to IRIS owners upon request if a non-disclosure agreement was signed.[10][11] Some Usenet posts claimed that the code was not supplied standalone, but as part of a "Software Exchange Release Tape". A fee of $100 was charged for this, and the user had to specifically request that the dog source code be included on the tape.[12] Others stated that this was for the physical media and shipping/handling, not the source code itself,[13] and that no charge was made if the IRIS owner supplied SGI with a blank tape of their own to put the code on.[14] Based on the dates of the various postings, it is possible that SGI initially supplied the code for free, but began charging for it at a later date.

Several programmers used this code as an example, to teach themselves UDP and how to use it in their own code.[3]

Another, unofficial, forked version replacing the UDP broadcast with point-to-point communication between two hosts was created at the Lund Institute of Technology in Sweden. The source code patch for this was posted on comp.sys.sgi in September 1989. The reason given for this fork was to allow machines on different subnets to play against each other.[15] It may also have been intended to reduce network congestion compared to the broadcast version.

An earlier forked version of dog with a different TCP/IP implementation may also have existed. Prior to 1988, the US Army's Ballistic Research Laboratory had a copy of the XNS version of the software, but XNS did not work on their network. An engineer by the name of Ron Natalie had access to the source code and was able to create a TCP/IP version.[16][17][18] This version communicated with a central server with its own "air traffic control" display.

There is no record of code from this version being used in the "official" version, or of its own networking implementation influencing the official one in any way. This means that the BRL version is probably an independent fork with different TCP/IP networking, which may not have been compatible with SGI's own. It may not even have used port 5130.

A server program called atc (Air Traffic Control) for dog was mentioned on comp.sys.sgi in November 1988.[19][20] This was probably Ron Natalie's air traffic control server, running on the BRL's forked version of dog. There is no evidence of such a feature ever being added to the "official" version.

For the IRIX 3.3 version, circa 1989, IP multicast capability was added,[4] and the game became playable between any compatible hosts on the Internet, assuming that they had multicast access (which was quite uncommon). The multicast address was 224.0.1.2 (SGI-DOG.MCAST.NET),[21] making this only the third multicast application to receive an address assignment, with only the Versatile Message Transaction Protocol (VMTP) protocol (224.0.1.0) and the Network Time Protocol (224.0.1.1) having arrived first.[citation needed] SGI would later use the same address for their objectserver daemon, which handled GUI icons.[21][22][23][24] This caused confusion for some system administrators.

Developers

A missile being launched

The manual page for the IRIX 6.5 (circa 1998) version of the program lists the following:[4]

  • Gary Tarolli (Original version)
  • Network communications David "Ciemo" Ciemiewicz (UDP broadcast[citation needed]) and Andrew Cherenson (IP multicast[citation needed]).
  • Rob Mace (Main coder by 1989,[25] maybe involved as far back as 1988.[citation needed] Listed as responsible for IRIX 6.5 version. Credited with the geometry for the F-14. Also co-credited with Thad Beier for the F-18, with Marc Ondrechen for the 727, and with Marshall Levine for the new instrument panel)
  • Barry Brouillette (Described as a "contributor", geometry for F-16 and P-38)
  • Marshall Levine (Described as a "contributor", co-credited with Rob Mace for the new instrument panel)
  • Thad Beier (Co-credited with Rob Mace for the F-18 geometry)
  • Marc Ondrechen (Co-credited with Rob Mace for the 727 geometry)
  • Sound effects by Chris Perry and Chris Schoeneman

Gameplay

The "city of lights"

In a 1991 Usenet posting, one user asked about an "interesting city" which the manual had claimed would exist north-north-west of the airport. Tarolli and others explained that there was no physical city at that location, but that lights were shown at night as if there were a city there.[26][27][28]

In-game physics

Yaw and roll coupling

The game's physics did not include yaw/roll coupling. Tarolli knew that this existed, but did not have a reference for the relevant equations and was unable to derive them himself. He was also unsure how much of an effect the shape of the wings would have, and whether yaw and roll would be strongly coupled for all shapes of wing.[29][30] As a result, he was unable to implement it in code.

Stall and spin

Two users complained about the game's stall/spin physics, arguing that stalls and spins did not occur as often as they would in real life, or in as many circumstances. They also complained about unrealistic behaviour when a stall did happen.[31][32]

In his response to this, Tarolli pointed out that while minor stalls were predictable, violent stalls were not. He also noted that modelling minor stalls would depend heavily on the wing design, and that it would require custom equations to be coded for every different wing shape on each of the planes. The calculations involved in modelling minor stalls would also be intensive and complicated enough to cause significant in-game slowdown.[33]

At least one user felt that the criticism levelled at Gary for the in-game physics was unfair, noting that flight and dog were intended primarily as fun games, not as precise simulations. He added that the relevant aerodynamics were often descibed in "a highly qualitative fashion" in relevant books, and that coding them into a simulation could be extremely difficult even if one had been able to learn them from such a book.[34] Tarolli himself noted that since he had not been able to model a real stall, he had coded random spins for very bad stalls (depending on how bad the stall was), in the hope that this would be "something fun" for the players.[35]

Use in academic research

1989

A group of researchers interfaced the flight simulator with the US military's SIMNET.[36] In their report, they stated:

"We were able to translate the SG "Dogfight" PDU's by "stealing" packets from the ETHERNET via a PC/AT with an Excelan 205E ETHERNET board installed. The software written to perform this operation uses UDP/IP to capture the SG broadcast packets and saves them to a disk file. Information contained in the SG PDU was reformatted or translated into SIMNET type packets, and then retransmitted over the ETHERNET to the SIMNET M1 tank modules."

The simulator itself ran on a Silicon Graphics 4D/70GT workstation.

1990

A researcher at the US Air Force Institute of Technology attempted to reduce the cost of flight simulators used in pilot training by using a head-mounted display with a simulator that could run on PC hardware.[37] As part of this, an attempt was made to port dog/flight to a PC platform based on a 20MHz 80386 processor with 80387 coprocessor, and a Real World Graphics Ltd. PC Reality board containing two Intel i860 RISC processors. The PC was running ESIX, a version of System V UNIX. Due to the presence of the head-mounted display, the PC also had to host a device to track user head movements.

The flight simulator program needed to maintain cross-platform portability, so rewriting it in assembler instead of C was not allowed. Calls to the SGI hardware graphics pipeline were "emulated", translated on-the-go to calls to the PC Reality board's library functions.

The planes used in the experiments were the F-14D, F-16, and Cessna C150. The Cessna model had a lower polygon count than either of the other two planes. Problems were mentioned with the PC's graphics software being unable to handle the F-15 model, although this may only have applied if another plane was also present.

For this experiment to be considered a success, the PC would have to achieve a frame rate of at least 15fps with Z-buffered, flat-shaded polygons. The PC's performance was also compared to that of the Silicon Graphics IRIS 4D/85GT with an unmodified version of the flight simulator.

It was noted that the unmodified version of dog used "makes extensive use of the Silicon Graphic's immediate mode graphics pipeline. In addition to including the new graphics functions released with the SGI 4D architecture, the program contains significant use of older functions that constituted the outdated SGI IRIS 31XX graphics pipeline methods. The SGI 4D machines provide built-in support for those older methods; however, they clearly identify that those methods do not optimally exploit the graphics pipeline provided in the 4D architecture."

However, the experiment was not a success. Some of the SGI functionality could not easily be ported/emulated, and was either omitted or replaced with a workaround. Wing stalls and G-limits were not enforced and all the aircraft were able to pull outside loops. Collision detection also had to be omitted, alowing the plane to fly through hangars, hills, and mountains. Furthermore, the PC Reality board was not able to support the polygon count or frame rate claimed, and some advertised capability was missing. Its approach to 3D graphics did not "allow for methods that write directly to the screen in device coordinates.", which caused problems. Only 4 frames per second were obtained, and even in tests with "an out-the-window view without the runway, buildings, or other terrain visible" no more than 10 fps could be achieved.

An additional research goal had been to network the PC and IRIS together, and to have them run dog interoperably. This was not achieved in the time available. One problem was that ESIX's UDP/IP support did not support programming below the OSI transport layer, unlike SGI's.

1992

Another group of researchers modified flight to log the actions of the human "pilot", and to use these logged actions as input to an "induction program". This program would use machine learning to create an autopilot for a specific flight plan.[38] The researchers chose the Cessna as their plane, stating that it was easier to learn how to fly the Cessna than any of the others. They also claimed that the rudder did not have "a realistic effect on the aircraft", although it is not clear if this claim applied only to the Cessna or to any/all of the other planes available. A poster on comp.sys.sgi had previously noted that the rudder would have a significant effect on a real-life Cessna, but had very little effect on the simulated Cessna of the flight program, and almost no effect on the other simulated planes in flight.[31]

The researchers noted that the flight simulator was non-deterministic, since it "runs on a multi-tasking Unix system, not on a dedicated real-time system. Thus, it is not possible to give a guaranteed real-time response because the flight simulator can be interrupted by other processes or I/O traffic." This meant that simply repeating the same set of inputs across multiple runs of the flight simulator would not be guaranteed to give the same results. The researchers hoped that the work they had done in addressing this problem would later be applicable to real-world situations, such as the effects of varying wind conditions on a plane.

See also

References

  1. ^ "SGI Dogfight". giantbomb.com. Retrieved 29 December 2021.
  2. ^ a b c d e f g Singhal, Sandeep; Zyda, Michael (1999). Networked Virtual Environments: Design and Implementation. Addison Wesley. ISBN 0201325578.
  3. ^ a b c d e f Zyda, Michael (2000). "Networked Virtual Environments in 75 Minutes!" (PDF). Archived (PDF) from the original on 17 April 2019. Archived 17 August 2022 at archive.today
  4. ^ a b c d e f "IRIX 6.5 Man Pages: FLIGHT(6D)". Archived from the original on 19 January 2016.
  5. ^ "Silicon Graphics Flight Simulator". Archived from the original on 3 March 2016.
  6. ^ a b c Smith, Roger (2003). "Evolution of Networked Virtual Environments (relevant text is concealed by the second image on the first page. To read it, highlight the whole of that page, then copy-paste into a text editor.)" (PDF). Archived from the original on 17 August 2022.
  7. ^ Millman, Miq (22 November 1988). "dog, radar, shadow, etc. & tcp/ip". Archived from the original on 20 August 2022.
  8. ^ Mace, Rob (8 December 1988). "Dogfight and others". Archived from the original on 20 August 2022.
  9. ^ Moore, Matthew (23 November 1988). "dog, radar, etc". Archived from the original on 20 August 2022.
  10. ^ a b "IRIS users discussion list archive, 1988". Archived from the original on 17 July 2007.
  11. ^ Mace, Rob (6 December 1988). "dog and arena". Archived from the original on 20 August 2022.
  12. ^ "dog on IRIS 3130". 14 July 1989. Archived from the original on 20 August 2022.
  13. ^ Seto, Keith (11 October 1990). "sources for GL demo programs". Archived from the original on 20 August 2022.
  14. ^ Moore, Matthew (6 December 1988). "Dogfight and Arena". Archived from the original on 20 August 2022.
  15. ^ "DOG: diff for point-to-point communication". 20 September 1989. Archived from the original on 20 August 2022.
  16. ^ Natalie, Ron. "Re: [TUHS] Gaming on early Unix". The Unix Heritage Society mailing list. Archived from the original on 20 January 2022.
  17. ^ "Ronald Natalie". LinkedIn.{{cite web}}: CS1 maint: url-status (link)
  18. ^ Hobson, Kevin (7 December 1988). "Dogfight and others". Archived from the original on 20 August 2022.
  19. ^ Dombroski, Robert M. (28 November 1988). "DOG". Archived from the original on 20 August 2022.
  20. ^ "dog, radar, shadow, etc. & tcp/ip". 29 November 1988. Archived from the original on 20 August 2022.
  21. ^ a b "Why is my SGI multicasting to SGI-DOG.MCAST.NET?". August 1994. Archived from the original on 7 May 2022. Archived 7 May 2022 at the Wayback Machine
  22. ^ "What is sending packets to the sgi-dog.mcast.net multicast address?". Archived from the original on 10 June 2021.
  23. ^ Mapleson, Ian. "UNIX Administration Course: Detailed Notes for Day 2". Archived from the original on 10 March 2021.
  24. ^ "Multicasting from workstations to SGI-DOG". February 1995. Archived from the original on 7 May 2022. Archived 20 August 2022 at archive.today
  25. ^ Tarolli, Gary (21 February 1989). "flight's concept of a 'good landing'".
  26. ^ "+-} Question on FLIGHT>Silcon Graphics". 8 June 1991. Archived from the original on 20 August 2022.
  27. ^ "+-} Question on FLIGHT>Silcon Graphics". 8 June 1991. Archived from the original on 20 August 2022.
  28. ^ Tarolli, Gary (11 June 1991). "+-} Question on FLIGHT>Silcon Graphics". Archived from the original on 20 August 2022.
  29. ^ Gigante, Mike A. (23 February 1989). "flight's concept of a 'good landing'". Archived from the original on 20 August 2022.
  30. ^ Tarolli, Gary (25 February 1989). "flight's concept of a 'good landing'". Archived from the original on 20 August 2022.
  31. ^ a b Frost, Jim (22 February 1989). "flight's concept of a 'good landing'". Archived from the original on 20 August 2022.
  32. ^ Bartels, Richard (22 February 1989). "flight's concept of a 'good landing'". Archived from the original on 20 August 2022.
  33. ^ Tarolli, Gary (22 February 1989). "flight's concept of a 'good landing'". Archived from the original on 20 August 2022.
  34. ^ VandeWettering, Mark (22 February 1989). "Flight Simulators... (was concept of good landing)". Archived from the original on 20 August 2022.
  35. ^ Tarolli, Gary (21 February 1989). "flight's concept of a 'good landing'". Archived from the original on 20 August 2022.
  36. ^ Cadiz, Jorge; Ouyang, Ruey; Thompson, Jack (5 October 1989). Interfacing of the Silicon Graphics Networkable Flight Simulator with SIMNET (PDF) (Technical report). University of Central Florida, Institute for Simulation and Training. IST-TR-89-1.
  37. ^ Dahn, David A. (1 December 1990). A Low-Cost Part-Task Flight Training System: An Application of a Head Mounted Display (PDF) (MSc). Air Force Institute of Technology.
  38. ^ Sammut, Claude; Hurst, Scott; Kedzier, Dana; Michie, Donald (1992). "Learning to Fly" (PDF). In Derek Sleeman; Peter Edwards (eds.). Machine Learning: Proceedings of the Ninth International Workshop (ML92). Morgan Kaufman. pp. 385–393. doi:10.1016/B978-1-55860-247-2.50055-3.
Retrieved from "https://en.wikipedia.org/enwiki/w/index.php?title=SGI_Dogfight&oldid=1105583902"