| // Copyright (c) 1996 Barry Silverman, Brian Silverman, Vadim Gerasimov. |
| // Portions Copyright (c) 2009 The Go Authors. |
| // |
| // Permission is hereby granted, free of charge, to any person obtaining a copy |
| // of this software and associated documentation files (the "Software"), to deal |
| // in the Software without restriction, including without limitation the rights |
| // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell |
| // copies of the Software, and to permit persons to whom the Software is |
| // furnished to do so, subject to the following conditions: |
| // |
| // The above copyright notice and this permission notice shall be included in |
| // all copies or substantial portions of the Software. |
| // |
| // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
| // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
| // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE |
| // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER |
| // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, |
| // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN |
| // THE SOFTWARE. |
| |
| // See ../../nacl/README. |
| |
| package main |
| |
| import ( |
| "bytes" |
| "exp/draw" |
| "exp/nacl/av" |
| "exp/nacl/srpc" |
| "image" |
| "log" |
| "os" |
| "runtime" |
| "time" |
| "./pdp1" |
| ) |
| |
| func main() { |
| runtime.LockOSThread() |
| if srpc.Enabled() { |
| go srpc.ServeRuntime() |
| } |
| |
| w, err := av.Init(av.SubsystemVideo, 512, 512) |
| if err != nil { |
| log.Exitf("av.Init: %s", err) |
| } |
| |
| kc := make(chan int) |
| go demuxEvents(w, kc) |
| |
| var m SpacewarPDP1 |
| m.Init(w, kc) |
| m.PC = 4 |
| f := bytes.NewBuffer([]byte(spacewarCode)) |
| if err = m.Load(f); err != nil { |
| log.Exitf("loading %s: %s", "spacewar.lst", err) |
| } |
| for err == nil { |
| //fmt.Printf("step PC=%06o ", m.PC); |
| //fmt.Printf("inst=%06o AC=%06o IO=%06o OV=%o\n", |
| // m.Mem[m.PC], m.AC, m.IO, m.OV); |
| err = m.Step() |
| } |
| log.Exitf("step: %s", err) |
| } |
| |
| func demuxEvents(w draw.Window, kc chan int) { |
| for event := range w.EventChan() { |
| switch e := event.(type) { |
| case draw.KeyEvent: |
| kc <- e.Key |
| } |
| } |
| os.Exit(0) |
| } |
| |
| // A SpacewarPDP1 is a PDP-1 machine configured to run Spacewar! |
| // It responds to traps by drawing on the display, and it flushes the |
| // display and pauses every second time the program counter reaches |
| // instruction 02051. |
| type SpacewarPDP1 struct { |
| pdp1.M |
| nframe int |
| frameTime int64 |
| ctxt draw.Window |
| dx, dy int |
| screen draw.Image |
| ctl pdp1.Word |
| kc <-chan int |
| colorModel image.ColorModel |
| cmap []image.Color |
| pix [][]uint8 |
| } |
| |
| func min(a, b int) int { |
| if a < b { |
| return a |
| } |
| return b |
| } |
| |
| func (m *SpacewarPDP1) Init(ctxt draw.Window, kc chan int) { |
| m.ctxt = ctxt |
| m.kc = kc |
| m.screen = ctxt.Screen() |
| m.dx = m.screen.Bounds().Dx() |
| m.dy = m.screen.Bounds().Dy() |
| m.colorModel = m.screen.ColorModel() |
| m.pix = make([][]uint8, m.dy) |
| for i := range m.pix { |
| m.pix[i] = make([]uint8, m.dx) |
| } |
| m.cmap = make([]image.Color, 256) |
| for i := range m.cmap { |
| var r, g, b uint8 |
| r = uint8(min(0, 255)) |
| g = uint8(min(i*2, 255)) |
| b = uint8(min(0, 255)) |
| m.cmap[i] = m.colorModel.Convert(image.RGBAColor{r, g, b, 0xff}) |
| } |
| } |
| |
| const ( |
| frameDelay = 56 * 1e6 // 56 ms |
| ) |
| |
| var ctlBits = [...]pdp1.Word{ |
| 'f': 0000001, |
| 'd': 0000002, |
| 'a': 0000004, |
| 's': 0000010, |
| '\'': 0040000, |
| ';': 0100000, |
| 'k': 0200000, |
| 'l': 0400000, |
| } |
| |
| func (m *SpacewarPDP1) Step() os.Error { |
| if m.PC == 02051 { |
| m.pollInput() |
| m.nframe++ |
| if m.nframe&1 == 0 { |
| m.flush() |
| t := time.Nanoseconds() |
| if t >= m.frameTime+3*frameDelay { |
| m.frameTime = t |
| } else { |
| m.frameTime += frameDelay |
| for t < m.frameTime { |
| time.Sleep(m.frameTime - t) |
| t = time.Nanoseconds() |
| } |
| } |
| } |
| } |
| return m.M.Step(m) |
| } |
| |
| func (m *SpacewarPDP1) Trap(y pdp1.Word) { |
| switch y & 077 { |
| case 7: |
| x := int(m.AC+0400000) & 0777777 |
| y := int(m.IO+0400000) & 0777777 |
| x = x * m.dx / 0777777 |
| y = y * m.dy / 0777777 |
| if 0 <= x && x < m.dx && 0 <= y && y < m.dy { |
| n := uint8(min(int(m.pix[y][x])+128, 255)) |
| m.pix[y][x] = n |
| } |
| case 011: |
| m.IO = m.ctl |
| } |
| } |
| |
| func (m *SpacewarPDP1) flush() { |
| // Update screen image; simulate phosphor decay. |
| for y := 0; y < m.dy; y++ { |
| for x := 0; x < m.dx; x++ { |
| m.screen.Set(x, y, m.cmap[m.pix[y][x]]) |
| m.pix[y][x] >>= 1 |
| } |
| } |
| m.ctxt.FlushImage() |
| } |
| |
| func (m *SpacewarPDP1) pollInput() { |
| for { |
| select { |
| case ch := <-m.kc: |
| if 0 <= ch && ch < len(ctlBits) { |
| m.ctl |= ctlBits[ch] |
| } |
| if 0 <= -ch && -ch < len(ctlBits) { |
| m.ctl &^= ctlBits[-ch] |
| } |
| default: |
| return |
| } |
| } |
| } |