Example #1
0
func (c *Controller) handleEvents() {
	// read all events
	for event := sdl.PollEvent(); event != nil; event = sdl.PollEvent() {
		switch et := event.(type) {
		case *sdl.QuitEvent:
			log.Println("Want to quit, but how do we apply this... ?")
			/*
				c.Destroy()
				return
				// NOTE: caller keeps calling Iterate because it doesn't know we're done... how to fix?
			*/
		case *sdl.KeyDownEvent:
			c.sendKeyEvents(sdl.GetKeyName(et.Keysym.Sym), true)
		case *sdl.KeyUpEvent:
			c.sendKeyEvents(sdl.GetKeyName(et.Keysym.Sym), false)
		// these are events we know but currently don't use FIXME implement
		case *sdl.WindowEvent:
		case *sdl.TextInputEvent:
		case *sdl.TextEditingEvent:
		case *sdl.MouseButtonEvent:
		case *sdl.MouseMotionEvent:
		case *sdl.MouseWheelEvent:
		default:
			log.Printf("Unknown event: %T\n", et)
		}
	}
}
Example #2
0
// CheckForUpdates polls sdl events and updates the map accordingly
func CheckForUpdates() bool {
	changeDetected := false

	// poll any current events
	var event sdl.Event
	for event = sdl.PollEvent(); event != nil; event = sdl.PollEvent() {
		switch t := event.(type) {
		case *sdl.QuitEvent:
			inputMap["Quit"] = true
		case *sdl.KeyDownEvent:
			if t.Keysym.Sym == sdl.K_ESCAPE {
				inputMap["Esc"] = true
			} else {
				// fmt.Printf("[%d ms] Keyboard\ttype:%d\tsym:%c\tmodifiers:%d\tstate:%d\trepeat:%d\n",
				// t.Timestamp, t.Type, t.Keysym.Sym, t.Keysym.Mod, t.State, t.Repeat)
			}
		default:
			// fmt.Printf("Some event\n")
		}

		changeDetected = true
	}

	return changeDetected
}
Example #3
0
func main() {

	start()
	defer window.Destroy()
	defer renderer.Destroy()

	text := loadText("Press enter to reset", sdl.Color{0, 0, 0, 255})
	startTime := sdl.GetTicks()

	quit := false
	for !quit {
		for e := sdl.PollEvent(); e != nil; e = sdl.PollEvent() {
			switch t := e.(type) {
			case *sdl.QuitEvent:
				quit = true
			case *sdl.KeyDownEvent:
				if t.Keysym.Sym == sdl.K_RETURN {
					startTime = sdl.GetTicks()
				}

			}
		}

		renderer.SetDrawColor(0xFF, 0xFF, 0xFF, 0xFF)
		renderer.Clear()
		timeText := loadText(fmt.Sprintf("time: %d", sdl.GetTicks()-startTime), sdl.Color{0, 0, 0, 255})
		renderer.Copy(text, nil, &sdl.Rect{0, 0, 400, 100})
		renderer.Copy(timeText, nil, &sdl.Rect{400, 0, 400, 100})

		renderer.Present()
	}
}
Example #4
0
func main() {
	rom, err := LoadROM(os.Args[1])

	if err != nil {
		panic(err)
	}

	frameDelay := 1000 / frameRate

	window := sdl.CreateWindow(
		"Go NES",
		sdl.WINDOWPOS_UNDEFINED,
		sdl.WINDOWPOS_UNDEFINED,
		256,
		240,
		sdl.WINDOW_SHOWN,
	)

	if window == nil {
		panic(sdl.GetError())
	}

	defer window.Destroy()

	controller := NewController()
	ppu := NewPPU(window, NewVRAM(rom.Mapper()))
	cpu := NewCPU(NewMMU(rom.Mapper(), ppu, controller), ppu)

	ticksPerFrame := uint32(341 * 262)

	for {
		expectedTicks := sdl.GetTicks() + frameDelay

		for event := sdl.PollEvent(); event != nil; event = sdl.PollEvent() {
			switch event := event.(type) {
			case *sdl.KeyDownEvent:
				controller.SetKeyState(event.Keysym.Sym, true)
			case *sdl.KeyUpEvent:
				controller.SetKeyState(event.Keysym.Sym, false)
			case *sdl.QuitEvent:
				return
			}
		}

		ppuTicks := uint32(0)

		for ppuTicks < ticksPerFrame {
			ppuTicks += ppu.Tick(cpu.Tick())
		}

		actualTicks := sdl.GetTicks()

		if actualTicks < expectedTicks {
			sdl.Delay(expectedTicks - actualTicks)
		}
	}
}
Example #5
0
func main() {
	var window *sdl.Window
	var renderer *sdl.Renderer
	var event sdl.Event
	var running bool

	window = sdl.CreateWindow(winTitle, sdl.WINDOWPOS_UNDEFINED, sdl.WINDOWPOS_UNDEFINED,
		winWidth, winHeight, sdl.WINDOW_SHOWN)
	if window == nil {
		fmt.Fprintf(os.Stderr, "Failed to create window: %s\n", sdl.GetError())
		os.Exit(1)
	}

	renderer = sdl.CreateRenderer(window, -1, sdl.RENDERER_ACCELERATED)
	if renderer == nil {
		fmt.Fprintf(os.Stderr, "Failed to create renderer: %s\n", sdl.GetError())
		os.Exit(2)
	}

	var peepArray []sdl.Event = make([]sdl.Event, 5)

	running = true
	for running {
		sdl.PumpEvents()
		numEventsRetrieved := sdl.PeepEvents(peepArray, sdl.PEEKEVENT, sdl.FIRSTEVENT, sdl.LASTEVENT)
		if numEventsRetrieved < 0 {
			fmt.Printf("PeepEvents error: %s\n", sdl.GetError())
		} else {
			for i := 0; i < numEventsRetrieved; i++ {
				fmt.Printf("Event Peeked Value: %v\n", peepArray[i]) // primitive printing of event
			}
		}

		for event = sdl.PollEvent(); event != nil; event = sdl.PollEvent() {
			switch t := event.(type) {
			case *sdl.QuitEvent:
				running = false
			case *sdl.MouseMotionEvent:
				fmt.Printf("[%d ms] MouseMotion\ttype:%d\tid:%d\tx:%d\ty:%d\txrel:%d\tyrel:%d\n",
					t.Timestamp, t.Type, t.Which, t.X, t.Y, t.XRel, t.YRel)
			case *sdl.MouseButtonEvent:
				fmt.Printf("[%d ms] MouseButton\ttype:%d\tid:%d\tx:%d\ty:%d\tbutton:%d\tstate:%d\n",
					t.Timestamp, t.Type, t.Which, t.X, t.Y, t.Button, t.State)
			case *sdl.MouseWheelEvent:
				fmt.Printf("[%d ms] MouseWheel\ttype:%d\tid:%d\tx:%d\ty:%d\n",
					t.Timestamp, t.Type, t.Which, t.X, t.Y)
			case *sdl.KeyUpEvent:
				fmt.Printf("[%d ms] Keyboard\ttype:%d\tsym:%c\tmodifiers:%d\tstate:%d\trepeat:%d\n",
					t.Timestamp, t.Type, t.Keysym.Sym, t.Keysym.Mod, t.State, t.Repeat)
			}
		}
		sdl.Delay(1000 / 30)
	}

	renderer.Destroy()
	window.Destroy()
}
Example #6
0
func main() {

	start()
	defer window.Destroy()
	defer renderer.Destroy()
	loadAudio()

	screens := loadScreens()

	quit := false

	cur := screens["main"]

	for !quit {
		for e := sdl.PollEvent(); e != nil; e = sdl.PollEvent() {
			switch t := e.(type) {
			case *sdl.QuitEvent:
				quit = true
			case *sdl.KeyDownEvent:
				switch t.Keysym.Sym {
				case sdl.K_1:
					high.PlayChannel(-1, 0)
				case sdl.K_2:
					medium.PlayChannel(-1, 0)
				case sdl.K_3:
					low.PlayChannel(-1, 0)
				case sdl.K_4:
					scratch.PlayChannel(-1, 0)
				case sdl.K_9:
					if !mix.MusicPlaying() {
						if !music.Play(1) {
							fmt.Printf("music did not play: %s", sdl.GetError())
						}
					} else {
						if !mix.PausedMusic() {
							mix.PauseMusic()
						} else {
							mix.ResumeMusic()
						}

					}
				}

			}

		}

		renderer.SetDrawColor(0xFF, 0xFF, 0xFF, 0xFF)
		renderer.Clear()

		renderer.Copy(cur, nil, nil)

		renderer.Present()
	}
}
Example #7
0
func catchEvents() bool {
	for event = sdl.PollEvent(); event != nil; event = sdl.PollEvent() {
		switch t := event.(type) {
		case *sdl.QuitEvent:
			return false
		case *sdl.KeyDownEvent:
			handleKeyEvent(t.Keysym.Sym)
		}
	}
	return true
}
Example #8
0
func (g *Engine) eventLoop() {
	g.Event = nil
	for event := sdl.PollEvent(); event != nil; event = sdl.PollEvent() {
		switch t := event.(type) {
		case *sdl.QuitEvent:
			g.Running = false

		case *sdl.KeyDownEvent:
			g.Event = &t.Keysym.Sym
		}
	}
}
Example #9
0
//wait for an event and returns the value of the event in key_mapping
func (c *Chip8) waitEvent() byte {

	for {
		for c.event = sdl.PollEvent(); c.event != nil; c.event = sdl.PollEvent() {
			switch event := c.event.(type) {
			case *sdl.KeyDownEvent:
				if code, found := c.key_mapping[event.Keysym.Sym]; found {
					return code
				}
			}
		}
	}
}
Example #10
0
func main() {
	var winTitle string = "Go-SDL2 + Go-GL"
	var winWidth, winHeight int = 800, 600
	var window *sdl.Window
	var context sdl.GLContext
	var event sdl.Event
	var running bool
	var err error

	if err = sdl.Init(sdl.INIT_EVERYTHING); err != nil {
		panic(err)
	}
	defer sdl.Quit()

	if err = gl.Init(); err != nil {
		panic(err)
	}

	window, err = sdl.CreateWindow(winTitle, sdl.WINDOWPOS_UNDEFINED, sdl.WINDOWPOS_UNDEFINED,
		winWidth, winHeight, sdl.WINDOW_OPENGL)
	if err != nil {
		panic(err)
	}
	defer window.Destroy()
	context, err = sdl.GL_CreateContext(window)
	if err != nil {
		panic(err)
	}
	defer sdl.GL_DeleteContext(context)

	gl.Enable(gl.DEPTH_TEST)
	gl.ClearColor(0.2, 0.2, 0.3, 1.0)
	gl.ClearDepth(1)
	gl.DepthFunc(gl.LEQUAL)
	gl.Viewport(0, 0, int32(winWidth), int32(winHeight))

	running = true
	for running {
		for event = sdl.PollEvent(); event != nil; event = sdl.PollEvent() {
			switch t := event.(type) {
			case *sdl.QuitEvent:
				running = false
			case *sdl.MouseMotionEvent:
				fmt.Printf("[%d ms] MouseMotion\tid:%d\tx:%d\ty:%d\txrel:%d\tyrel:%d\n", t.Timestamp, t.Which, t.X, t.Y, t.XRel, t.YRel)
			}
		}
		drawgl()
		sdl.GL_SwapWindow(window)
	}
}
Example #11
0
func main() {
	window, renderer = tools.Start("planets", int(SCREEN_W), int(SCREEN_H))
	wideView := tools.ViewBox{tools.Vector{-SCREEN_SCALE / 2 / float64(SCREEN_H) * float64(SCREEN_W),
		-SCREEN_SCALE / 2},
		SCREEN_SCALE / float64(SCREEN_H) * float64(SCREEN_W),
		SCREEN_SCALE}
	defer window.Destroy()
	defer renderer.Destroy()
	sprite = tools.LoadTextureTransparent(renderer, "resources/sprites.png", 0, 0xFF, 0xFF)

	bodies := []*tools.Body{&Sun, &Earth, &Mars, &Ecc}

	quit := false
	curView := &wideView
	for !quit {
		for e := sdl.PollEvent(); e != nil; e = sdl.PollEvent() {
			switch t := e.(type) {
			case *sdl.QuitEvent:
				quit = true
			case *sdl.KeyDownEvent:
				switch t.Keysym.Sym {
				case sdl.K_UP:
					auto := tools.GetAutoView(
						[]tools.Vector{
							bodies[0].Position,
							bodies[1].Position},
						SCREEN_RATIO)
					curView = &auto
				case sdl.K_DOWN:
					curView = &wideView
				case sdl.K_q:
					quit = true
				}
				// fmt.Println("View:", curView)
			}

		}
		// Draw background
		renderer.SetDrawColor(0xFF, 0xFF, 0xFF, 0xFF)
		renderer.Clear()

		renderer.SetDrawColor(0, 0, 0, 0xFF)

		tools.UpdateBodiesSeconds(bodies, 60*60*24*7)
		DrawBodies(bodies, *curView)

		renderer.Present()
		//fmt.Println(earth.Position, sun.Position)
	}
}
Example #12
0
func (i *InputHandler) HandleEvents() {
	i.pressed_keys_this_frame = make([]sdl.Keycode, 10)
	i.released_keys_this_frame = make([]sdl.Keycode, 10)

	for event := sdl.PollEvent(); event != nil; event = sdl.PollEvent() {
		switch t := event.(type) {
		case *sdl.KeyDownEvent:
			i.pressed_keys_this_frame = append(i.pressed_keys_this_frame, t.Keysym.Sym)
			i.pressed_keys[t.Keysym.Sym] = true
		case *sdl.KeyUpEvent:
			i.released_keys_this_frame = append(i.released_keys_this_frame, t.Keysym.Sym)
			i.pressed_keys[t.Keysym.Sym] = false
		}
	}
}
Example #13
0
func main() {
	window, err := sdl.CreateWindow("Monster Path",
		sdl.WINDOWPOS_UNDEFINED, sdl.WINDOWPOS_UNDEFINED,
		640, 480, sdl.WINDOW_SHOWN)

	if err != nil {
		os.Exit(1)
	}
	defer window.Destroy()

	renderer, err := sdl.CreateRenderer(window, -1, sdl.RENDERER_ACCELERATED)
	if err != nil {
		os.Exit(2)
	}
	defer renderer.Destroy()

	var event sdl.Event
	running := true

	myGrid := grid.New(17, 12)
	setupMap(myGrid)
	gunner.location, _ = myGrid.RoomAt(15, 7)
	alien.location, _ = myGrid.RoomAt(1, 1)
	graph := graph.NewFromGrid(myGrid)
	path := graph.Path(gunner.location, alien.location)
	for running {
		for event = sdl.PollEvent(); event != nil; event = sdl.PollEvent() {
			switch event.(type) {
			case *sdl.QuitEvent:
				running = false
			}
		}

		renderer.SetDrawColor(205, 201, 201, 255)
		renderer.Clear()

		renderer.SetDrawColor(10, 10, 10, 255)
		Draw(renderer, myGrid)
		DrawGraph(renderer, graph)
		renderer.SetDrawColor(200, 0, 0, 255)
		DrawPath(renderer, path)

		renderer.SetDrawColor(0, 100, 0, 255)
		alien.Draw(renderer)
		gunner.Draw(renderer)
		renderer.Present()
	}
}
func (p *PlayerFrontend) processInput() {
	for ev := sdl.PollEvent(); ev != nil; ev = sdl.PollEvent() {
		input := Input{}
		for _, v := range p.inputs {
			earlyExit, in := v.ProcessEvent(ev, p)
			if in != nil {
				input.Combine(in)
			}
			if earlyExit {
				break
			}
		}
		input.Normalize()
		p.sendInput(input)
	}
}
Example #15
0
File: poll.go Project: eandre/drip
func Poll() Event {
	e := sdl.PollEvent()
	if e == nil {
		return nil
	}
	return wrapEvent(e)
}
Example #16
0
// GetKey returns the key or button that has been pressed by the user.
// Possible return values are the constants:
//
//  KeyNone - indicating that no key, or an unrecognised key as been pressed
//  KeyUp	- indicating that the up cursor key has been pressed
//  KeyDown - indicating that the down cursor key has been pressed
//  KeyPause - indicating that the pause key has been presses
//  ButtonClose - indicating that the windows close button has been pressed
//
// GetKey will panic if:
//
// 1. The toolbox has not been initialised.
//
// 2. If an internal check fails. In this case the panic message is "KeyDownEvent type assertion failed!"
// This is highly unlikely to occur and indcates a problem with the underlying
// graphics llibrary.
func GetKey() Key {
	if !initialised {
		// this stops execution here, so ne need for an else after the if
		panic(notInitialisedMessage)
	}

	var event sdl.Event
	event = sdl.PollEvent()
	if event != nil {
		if isQuitEvent(event) {
			return ButtonClose
		}
		if isKeyDownEvent(event) {
			if isKeyUp(event) {
				return KeyUp
			}
			if isKeyDown(event) {
				return KeyDown
			}
			// We must always respond to the paused key being pressed - if the
			// game is not over.
			// If the game is running the pause key pauses the game.
			// But if the game is paused, we must still respond to the paused key.
			// This is the only way to unpause the game.
			if isKeyPause(event) {
				return KeyPause
			}
		}
	}
	return KeyNone
}
func (mc *MissionControl) Start() {
	var event sdl.Event
	var running bool = true

	for running {
		for event = sdl.PollEvent(); event != nil; event = sdl.PollEvent() {
			switch t := event.(type) {
			case *sdl.QuitEvent:
				running = false
			case *sdl.MouseMotionEvent:
				fmt.Printf("[%d ms] MouseMotion\ttype:%d\tid:%d\tx:%d\ty:%d\txrel:%d\tyrel:%d\n",
					t.Timestamp, t.Type, t.Which, t.X, t.Y, t.XRel, t.YRel)
			case *sdl.MouseButtonEvent:
				fmt.Printf("[%d ms] MouseButton\ttype:%d\tid:%d\tx:%d\ty:%d\tbutton:%d\tstate:%d\n",
					t.Timestamp, t.Type, t.Which, t.X, t.Y, t.Button, t.State)
			case *sdl.MouseWheelEvent:
				fmt.Printf("[%d ms] MouseWheel\ttype:%d\tid:%d\tx:%d\ty:%d\n",
					t.Timestamp, t.Type, t.Which, t.X, t.Y)
			case *sdl.KeyUpEvent:
				fmt.Printf("[%d ms] Keyboard\ttype:%d\tsym:%c\tmodifiers:%d\tstate:%d\trepeat:%d\n",
					t.Timestamp, t.Type, t.Keysym.Sym, t.Keysym.Mod, t.State, t.Repeat)
				// Quit on escape
				if t.Keysym.Sym == sdl.K_ESCAPE {
					running = false
				}
			}
		}

		// Update each widget
		for _, d := range mc.drawables {
			d.Update()
		}

		// This will update the entire screen to this color
		SetDrawColor(mc.renderer, mc.background_color)
		mc.renderer.Clear()

		// Update the ui
		for _, d := range mc.drawables {
			d.Draw(mc.renderer)
		}

		mc.renderer.Present()

		// We need to sleep the remainder of the frame here
	}
}
Example #18
0
func get_event() {
	for event := sdl.PollEvent(); event != nil; event = sdl.PollEvent() {
		switch e := event.(type) {
		case *sdl.WindowEvent:
			if e.Event == sdl.WINDOWEVENT_FOCUS_LOST && game.state == PLAY {
				game.state = PAUSE
			}
		case *sdl.QuitEvent:
			window.Destroy()
			os.Exit(0)
		case *sdl.KeyDownEvent:
			control.UpdateKey(int(e.Keysym.Sym), true)
		case *sdl.KeyUpEvent:
			control.UpdateKey(int(e.Keysym.Sym), false)
		}
	}
}
Example #19
0
func run() int {
	var window *sdl.Window
	var renderer *sdl.Renderer
	var event sdl.Event
	var running bool
	var err error

	window, err = sdl.CreateWindow(winTitle, sdl.WINDOWPOS_UNDEFINED, sdl.WINDOWPOS_UNDEFINED,
		winWidth, winHeight, sdl.WINDOW_SHOWN)
	if err != nil {
		fmt.Fprintf(os.Stderr, "Failed to create window: %s\n", err)
		return 1
	}
	defer window.Destroy()

	renderer, err = sdl.CreateRenderer(window, -1, sdl.RENDERER_ACCELERATED)
	if err != nil {
		fmt.Fprintf(os.Stderr, "Failed to create renderer: %s\n", err)
		return 2
	}
	defer renderer.Destroy()

	running = true
	for running {
		for event = sdl.PollEvent(); event != nil; event = sdl.PollEvent() {
			switch t := event.(type) {
			case *sdl.QuitEvent:
				running = false
			case *sdl.MouseMotionEvent:
				fmt.Printf("[%d ms] MouseMotion\ttype:%d\tid:%d\tx:%d\ty:%d\txrel:%d\tyrel:%d\n",
					t.Timestamp, t.Type, t.Which, t.X, t.Y, t.XRel, t.YRel)
			case *sdl.MouseButtonEvent:
				fmt.Printf("[%d ms] MouseButton\ttype:%d\tid:%d\tx:%d\ty:%d\tbutton:%d\tstate:%d\n",
					t.Timestamp, t.Type, t.Which, t.X, t.Y, t.Button, t.State)
			case *sdl.MouseWheelEvent:
				fmt.Printf("[%d ms] MouseWheel\ttype:%d\tid:%d\tx:%d\ty:%d\n",
					t.Timestamp, t.Type, t.Which, t.X, t.Y)
			case *sdl.KeyUpEvent:
				fmt.Printf("[%d ms] Keyboard\ttype:%d\tsym:%c\tmodifiers:%d\tstate:%d\trepeat:%d\n",
					t.Timestamp, t.Type, t.Keysym.Sym, t.Keysym.Mod, t.State, t.Repeat)
			}
		}
	}

	return 0
}
Example #20
0
File: input.go Project: fmd/gogol
func (i *Input) Handle() {
	var event sdl.Event

	copy(i.oldKeyStates, i.KeyStates)
	for event = sdl.PollEvent(); event != nil; event = sdl.PollEvent() {
		switch e := event.(type) {
		case *sdl.QuitEvent:
			G.Quit = true
		case *sdl.MouseButtonEvent:
			i.handleMouseButtonEvent(e)
		case *sdl.KeyDownEvent:
			i.handleKeyDownEvent(e)
		case *sdl.KeyUpEvent:
			i.handleKeyUpEvent(e)
		}
	}
}
Example #21
0
func main() {

	start()
	defer window.Destroy()
	defer renderer.Destroy()

	screens := loadScreens()

	quit := false

	cur := screens["main"]

	for !quit {
		for e := sdl.PollEvent(); e != nil; e = sdl.PollEvent() {
			switch e.(type) {
			case *sdl.QuitEvent:
				quit = true

			}
		}
		curKeyState := sdl.GetKeyboardState()
		switch {
		case curKeyState[sdl.SCANCODE_UP] != 0:
			cur = screens["up"]
		case curKeyState[sdl.SCANCODE_DOWN] != 0:
			cur = screens["down"]
		case curKeyState[sdl.SCANCODE_LEFT] != 0:
			cur = screens["left"]
		case curKeyState[sdl.SCANCODE_RIGHT] != 0:
			cur = screens["right"]
		default:
			cur = screens["main"]
		}

		renderer.SetDrawColor(0xFF, 0xFF, 0xFF, 0xFF)
		renderer.Clear()

		renderer.Copy(cur, nil, nil)

		renderer.Present()
	}
}
Example #22
0
func main() {
	window, renderer = tools.Start("flip", int(W), int(H))
	defer window.Destroy()
	defer renderer.Destroy()

	arrow := tools.LoadTexture(renderer, "resources/arrow.png")
	back := tools.LoadTexture(renderer, "resources/background.png")

	angle := 0.0
	var flip = sdl.RendererFlip(sdl.FLIP_NONE)

	quit := false
	for !quit {
		for e := sdl.PollEvent(); e != nil; e = sdl.PollEvent() {
			switch t := e.(type) {
			case *sdl.QuitEvent:
				quit = true
			case *sdl.KeyDownEvent:
				switch t.Keysym.Sym {
				case sdl.K_LEFT:
					angle += 30.0
				case sdl.K_RIGHT:
					angle -= 30.0
				case sdl.K_q:
					flip ^= sdl.FLIP_HORIZONTAL
				case sdl.K_w:
					flip ^= sdl.FLIP_VERTICAL
				}

			}
		}

		renderer.SetDrawColor(0xFF, 0xFF, 0xFF, 0xFF)
		renderer.Clear()

		renderer.Copy(back, nil, nil)
		renderer.CopyEx(arrow, nil, &sdl.Rect{300, 400, 100, 100},
			angle, &sdl.Point{50, 50}, flip)

		renderer.Present()
	}
}
Example #23
0
func (dmg *DMG) exec() {
	run := true

	for run {
		for event := sdl.PollEvent(); event != nil; event = sdl.PollEvent() {
			switch e := event.(type) {
			case *sdl.QuitEvent:
				run = false
			case *sdl.KeyUpEvent:
				dmg.keypad.keyup(uint8(e.Keysym.Sym))
			case *sdl.KeyDownEvent:
				dmg.keypad.keydown(uint8(e.Keysym.Sym))
			}
		}

		dmg.cpu.exec()
	}

	dmg.lcdController.shutdown()
}
Example #24
0
func processInput(quit chan bool) {
	var event sdl.Event
	for event = sdl.PollEvent(); event != nil; event = sdl.PollEvent() {
		switch t := event.(type) {
		case *sdl.QuitEvent:
			close(quit)
		case *sdl.MouseMotionEvent:
			fmt.Printf("[%d ms] MouseMotion\ttype:%d\tid:%d\tx:%d\ty:%d\txrel:%d\tyrel:%d\n",
				t.Timestamp, t.Type, t.Which, t.X, t.Y, t.XRel, t.YRel)
		case *sdl.MouseButtonEvent:
			fmt.Printf("[%d ms] MouseButton\ttype:%d\tid:%d\tx:%d\ty:%d\tbutton:%d\tstate:%d\n",
				t.Timestamp, t.Type, t.Which, t.X, t.Y, t.Button, t.State)
		case *sdl.MouseWheelEvent:
			fmt.Printf("[%d ms] MouseWheel\ttype:%d\tid:%d\tx:%d\ty:%d\n",
				t.Timestamp, t.Type, t.Which, t.X, t.Y)
		case *sdl.KeyDownEvent:
			if t.Keysym.Sym == 1073741904 { // left arrow
				cam.Orientation[0] -= oneDegree
			}
			if t.Keysym.Sym == 1073741903 { // right arrow
				cam.Orientation[0] += oneDegree
			}
			if cam.Orientation[0] < 0 {
				cam.Orientation[0] = 2 * math.Pi
			}
			if cam.Orientation[0] > 2*math.Pi {
				cam.Orientation[0] = 0
			}
			fmt.Printf("cam.Orientation[0] = %f\n", cam.Orientation[0])
			pt := vec3.T{10, 20, 3}
			sp := perspProj(&pt, cam)
			fmt.Printf("sp: %v\n", sp)
		case *sdl.KeyUpEvent:
			fmt.Printf("[%d ms] Keyboard\ttype:%d\tsym:%c\tcode:%d\tmodifiers:%d\n",
				t.Timestamp, t.Type, t.Keysym.Sym, t.Keysym.Sym, t.Keysym.Mod)
			if t.Keysym.Sym == 27 || t.Keysym.Sym == 1073741881 /* Caps Lock */ {
				close(quit)
			}
		}
	}
}
Example #25
0
// CheckQuit checks if the user has clicked the window's close button.
// If the user has then the quit variable is set it true. CheckQuit returns
// the value of the quit variable.
func checkQuit() bool {
	var event sdl.Event
	event = sdl.PollEvent()

	if event != nil {
		switch event.(type) {
		case *sdl.QuitEvent:
			quit = true
		}
	}
	return quit
}
Example #26
0
// GetNextEvent returns the next sdl.Event depending on the eventMode
func (g *GameManager) GetNextEvent() sdl.Event {
	switch g.eventMode {
	case GameManagerEventDriven:
		return sdl.WaitEvent()
	case GameManagerEventTimeoutDriven:
		return sdl.WaitEventTimeout(g.EventTimeout)
	case GameManagerPollDriven:
		return sdl.PollEvent()
	}

	panic(fmt.Sprintf("GetNextEvent: unknown event mode: %d", g.eventMode))
}
Example #27
0
func (events *Events) GetEvents() {
	for event := sdl.PollEvent(); event != nil; event = sdl.PollEvent() {
		switch t := event.(type) {

		case *sdl.QuitEvent:
			os.Exit(0)

		case *sdl.KeyDownEvent:
			if t.Repeat != 0 {
				continue
			}

			switch t.Keysym.Scancode {
			case sdl.SCANCODE_UP:
				events.up = true
			case sdl.SCANCODE_DOWN:
				events.down = true
			case sdl.SCANCODE_LEFT:
				events.left = true
			case sdl.SCANCODE_RIGHT:
				events.right = true
			case sdl.SCANCODE_ESCAPE:
				os.Exit(0)
			}

		case *sdl.KeyUpEvent:
			switch t.Keysym.Scancode {
			case sdl.SCANCODE_UP:
				events.up = false
			case sdl.SCANCODE_DOWN:
				events.down = false
			case sdl.SCANCODE_LEFT:
				events.left = false
			case sdl.SCANCODE_RIGHT:
				events.right = false
			}
		}
	}
}
Example #28
0
func (controlManager *ControlManager) ReadInput() Update {
	Running = true
	allSym, allKeys, allFKeys := controlManager.getDirectPointers()

	return func(state int) int {
		if Running {
			controlManager.Player1.ResetFrameKey()
			controlManager.Player2.ResetFrameKey()
			event := sdl.PollEvent()
			for event != nil {
				switch t := event.(type) {
				case *sdl.QuitEvent:
					Running = false
				case *sdl.KeyUpEvent:
					for i := 0; i < 16; i++ {
						if t.Keysym.Sym == allSym[i] {
							*allKeys[i] = false
						}
					}
				case *sdl.KeyDownEvent:
					for i := 0; i < 16; i++ {
						if t.Keysym.Sym == allSym[i] {
							if t.Repeat == 0 {
								*allKeys[i] = true
								*allFKeys[i] = true
							}
						}
					}
				}
				event = sdl.PollEvent()
			}
		} else {
			controlManager.Running = false
			return -1
		}

		return 0
	}
}
Example #29
0
// Poll is used by the game loop to gather events and delegate to each pacakge.
// Generally you should not have to use this method however if you are doing your
// own game loop this should be called at the end.
func Poll() {
	for event := sdl.PollEvent(); event != nil; event = sdl.PollEvent() {
		switch e := event.(type) {
		case *sdl.WindowEvent:
			delegateWindowEvent(event, e)
		case *sdl.KeyDownEvent, *sdl.KeyUpEvent, *sdl.TextEditingEvent, *sdl.TextInputEvent:
			keyboard.Delegate(e)
		case *sdl.MouseMotionEvent, *sdl.MouseButtonEvent, *sdl.MouseWheelEvent:
			mouse.Delegate(e)
		case *sdl.JoyAxisEvent, *sdl.JoyBallEvent, *sdl.JoyHatEvent,
			*sdl.JoyButtonEvent, *sdl.JoyDeviceEvent, *sdl.ControllerAxisEvent,
			*sdl.ControllerButtonEvent, *sdl.ControllerDeviceEvent:
			joystick.Delegate(e)
		case *sdl.TouchFingerEvent:
			touch.Delegate(e)
		case *sdl.QuitEvent:
			window.Close(true)
		case *sdl.DropEvent, *sdl.RenderEvent, *sdl.UserEvent,
			*sdl.ClipboardEvent, *sdl.OSEvent, *sdl.CommonEvent:
			//discard not used in amore yet
		}
	}
}
Example #30
0
// HandleEvents is used for receiving and handling SDL Events such as
// Update the mouse location, Check if the user is requesting to close the game, etc.
func HandleEvents() {
	event := sdl.PollEvent()

	switch event.(type) {
	case *sdl.QuitEvent:
		log.Println("Game // Got Quit Event. Stopping Game ...")
		running = false
		break
	default:
		input.HandleEvents(event)
		currentScene.HandleEvents(event)
		break
	}
}