Пример #1
0
// Initializes SDL
func (e *Engine) Init() (err error) {
	err = sdl.Init(sdl.INIT_VIDEO | sdl.INIT_AUDIO)
	if err != nil {
		return
	}

	err = mix.Init(mix.INIT_OGG)
	if err != nil {
		return
	}

	err = ttf.Init()
	if err != nil {
		return
	}

	err = mix.OpenAudio(mix.DEFAULT_FREQUENCY, mix.DEFAULT_FORMAT, mix.DEFAULT_CHANNELS, 3072)
	if err != nil {
		return
	}

	e.Window, err = sdl.CreateWindow(WinTitle, sdl.WINDOWPOS_UNDEFINED, sdl.WINDOWPOS_UNDEFINED, WinWidth, WinHeight, sdl.WINDOW_SHOWN)
	if err != nil {
		return
	}

	e.Renderer, err = sdl.CreateRenderer(e.Window, -1, sdl.RENDERER_ACCELERATED)
	if err != nil {
		return
	}

	return
}
Пример #2
0
/*
Build creates a Controller struct. NOTE: locks the OS thread. Make sure to call
all Controller.func from the exact same goroutine, otherwise the SDL context
may crash!
*/
func Build() (*Controller, error) {
	// MUST guarantee controller always runs in same OS thread
	runtime.LockOSThread()
	sdl.Init(sdl.INIT_EVERYTHING)
	// prepare basic Controller stuff
	c := &Controller{}
	c.renderable = makeOrdered()
	c.entities = make(map[string]interface{})
	c.keyreceivers = make(map[string][]*keyReceive)
	c.textCache = make(map[string]*sdl.Texture)
	// window
	window, err := sdl.CreateWindow("Orbiting", sdl.WINDOWPOS_UNDEFINED, sdl.WINDOWPOS_UNDEFINED, 800, 600, sdl.WINDOW_SHOWN)
	if err != nil {
		return nil, err
	}
	c.window = window
	// create renderer (reference kept by window, no need to do it ourselves)
	renderer, err := sdl.CreateRenderer(c.window, -1, 0)
	if err != nil {
		return nil, err
	}
	// however, we DO want to keep just a single instance of the wrapper
	c.wrapped = &Renderer{renderer: renderer}
	return c, nil
}
Пример #3
0
func main() {
	if err := sdl.Init(sdl.INIT_AUDIO); err != nil {
		log.Println(err)
		return
	}

	if err := mix.Init(mix.INIT_MP3); err != nil {
		log.Println(err)
		return
	}
	defer sdl.Quit()
	defer mix.Quit()
	defer mix.CloseAudio()

	if err := mix.OpenAudio(22050, mix.DEFAULT_FORMAT, 2, 4096); err != nil {
		log.Println(err)
		return
	}

	if music, err := mix.LoadMUS("test.mp3"); err != nil {
		log.Println(err)
	} else if err = music.Play(1); err != nil {
		log.Println(err)
	} else {
		sdl.Delay(5000)
		music.Free()
	}
}
Пример #4
0
func start() {
	if sdl.Init(sdl.INIT_AUDIO) < 0 {
		fmt.Fprintf(os.Stderr, "Failed to init:", sdl.GetError())
		os.Exit(1)
	}

	window = sdl.CreateWindow("test", sdl.WINDOWPOS_UNDEFINED, sdl.WINDOWPOS_UNDEFINED,
		int(W), int(H), 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|sdl.RENDERER_PRESENTVSYNC)
	if renderer == nil {
		fmt.Fprintf(os.Stderr, "Failed to create renderer: %s\n", sdl.GetError())
		os.Exit(1)
	}

	mix.SetSoundFonts("resources/")
	if !mix.OpenAudio(44100, mix.DEFAULT_FORMAT, 2, 2048) {
		fmt.Fprintf(os.Stderr, "Failed to open audio:%s\n", sdl.GetError())
		os.Exit(1)
	}

}
Пример #5
0
func (dmg *DMG) Run(file string, width, height int) {
	sdl.Init(sdl.INIT_VIDEO)
	defer sdl.Quit()

	dmg.init(file, width, height)
	dmg.exec()
}
Пример #6
0
func Init() error {
	// This is needed to make sure that we are always running the graphics code in the same OS thread as it is initialized in.
	runtime.LockOSThread()
	if runtime.GOMAXPROCS(-1) == 1 {
		runtime.GOMAXPROCS(2)
	}
	return sdl.Init(sdl.INIT_EVERYTHING)
}
Пример #7
0
func OpenDisplay(width uint32, height uint32) (*Display, error) {
	display := Display{}

	sdl.Init(sdl.INIT_EVERYTHING)
	window, err := sdl.CreateWindow("test", sdl.WINDOWPOS_UNDEFINED, sdl.WINDOWPOS_UNDEFINED, int(width), int(height), sdl.WINDOW_SHOWN)
	if err != nil {
		return nil, err
	}
	display.window = window

	return &display, nil
}
Пример #8
0
// NewAdaptor returns a new Joystick Adaptor.
func NewAdaptor() *Adaptor {
	return &Adaptor{
		name: "Joystick",
		connect: func(j *Adaptor) (err error) {
			sdl.Init(sdl.INIT_JOYSTICK)
			if sdl.NumJoysticks() > 0 {
				j.joystick = sdl.JoystickOpen(0)
				return
			}
			return errors.New("No joystick available")
		},
	}
}
Пример #9
0
// NewJoystickAdaptor returns a new JoystickAdaptor with specified name.
func NewJoystickAdaptor(name string) *JoystickAdaptor {
	return &JoystickAdaptor{
		name: name,
		connect: func(j *JoystickAdaptor) (err error) {
			sdl.Init(sdl.INIT_JOYSTICK)
			if sdl.NumJoysticks() > 0 {
				j.joystick = sdl.JoystickOpen(0)
				return
			}
			return errors.New("No joystick available")
		},
	}
}
Пример #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)
	}
}
Пример #11
0
func initSDL() *sdl.Window {
	sdl.Init(sdl.INIT_EVERYTHING)

	window, err := sdl.CreateWindow("Game of Life",
		sdl.WINDOWPOS_UNDEFINED,
		sdl.WINDOWPOS_UNDEFINED,
		1280, 720,
		sdl.WINDOW_OPENGL)
	if err != nil {
		panic(err)
	}

	return window
}
Пример #12
0
func (engine *GameEngine) Init(name string) {
	sdl.Init(sdl.INIT_EVERYTHING)
	ttf.Init()

	engine.window = sdl.CreateWindow(name, sdl.WINDOWPOS_UNDEFINED, sdl.WINDOWPOS_UNDEFINED, 800, 600, sdl.WINDOW_SHOWN)
	engine.renderer = sdl.CreateRenderer(engine.window, -1, sdl.RENDERER_ACCELERATED|sdl.RENDERER_PRESENTVSYNC)
	engine.Input = &InputHandler{}
	engine.Assets = &AssetsManager{}

	engine.Input.Init()
	engine.Assets.Init(engine)

	engine.Running = true
	engine.states = NewStack()
}
Пример #13
0
func run() int {
	var window *sdl.Window
	var font *ttf.Font
	var surface *sdl.Surface
	var solid *sdl.Surface
	var err error

	sdl.Init(sdl.INIT_VIDEO)

	if err := ttf.Init(); err != nil {
		fmt.Fprintf(os.Stderr, "Failed to initialize TTF: %s\n", err)
		return 1
	}

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

	if font, err = ttf.OpenFont("../../assets/test.ttf", 32); err != nil {
		fmt.Fprint(os.Stderr, "Failed to open font: %s\n", err)
		return 4
	}
	defer font.Close()

	if solid, err = font.RenderUTF8_Solid("Hello, World!", sdl.Color{255, 0, 0, 255}); err != nil {
		fmt.Fprint(os.Stderr, "Failed to render text: %s\n", err)
		return 5
	}
	defer solid.Free()

	if surface, err = window.GetSurface(); err != nil {
		fmt.Fprint(os.Stderr, "Failed to get window surface: %s\n", err)
		return 6
	}

	if err = solid.Blit(nil, surface, nil); err != nil {
		fmt.Fprint(os.Stderr, "Failed to put text on window surface: %s\n", err)
		return 7
	}

	// Show the pixels for a while
	window.UpdateSurface()
	sdl.Delay(3000)

	return 0
}
Пример #14
0
func sdlInit() {

	sdl.Init(sdl.INIT_EVERYTHING)

	// init the image subsystem
	imgFlags := img.INIT_PNG | img.INIT_JPG

	if imgFlags != img.Init(imgFlags) {
		panic(fmt.Sprintf("Error initializing img: %v\n", img.GetError()))
	}

	// init the TTF subsystem
	if err := ttf.Init(); err != nil {
		panic(fmt.Sprintf("Error initializing ttf: %v\n", err))
	}
}
Пример #15
0
func main() {

	if len(os.Args) < 2 {
		fmt.Println("usage: emuChip8 <game>")
		os.Exit(1)
	}

	sdl.Init(sdl.INIT_EVERYTHING)
	window, err := sdl.CreateWindow("Chip8", sdl.WINDOWPOS_UNDEFINED, sdl.WINDOWPOS_UNDEFINED,
		WIN_WIDTH, WIN_HEIGHT, sdl.WINDOW_SHOWN)

	if err != nil {
		panic(err)
	}
	defer window.Destroy()

	surface, err := window.GetSurface()
	if err != nil {
		panic(err)
	}

	chip := new(Chip8)
	chip.surface = surface
	chip.init()
	chip.loadGame(os.Args[1])

	chip.quit = false
	for !chip.quit {

		if err := chip.emulateCycle(); err != nil {
			fmt.Println(err)
		}

		if chip.drawFlag {
			chip.drawGraphics()
			window.UpdateSurface()
			chip.drawFlag = false
		}

		chip.setKeys()
		sdl.Delay(1)

	}

	chip.cleanup()

}
Пример #16
0
// Init is used for a starting procedure of the game which will do things
// such as creating the SDL Window, creating the SDL Renderer, Start the Scene, etc.
func Init(title string, x, y, width, height int, fullscreen bool) {
	var flags uint32

	if fullscreen {
		flags = sdl.WINDOW_FULLSCREEN
	}

	err := sdl.Init(sdl.INIT_EVERYTHING)

	if err != nil {
		log.Fatalln("Game // Error whie initialising SDL")
		log.Panic(err)
	}

	log.Println("Game // SDL Initialised")

	win, err := sdl.CreateWindow(title, x, y, width, height, flags)

	if err != nil {
		log.Fatalln("Game // Error while creating window")
		log.Panic(err)
	}

	log.Println("Game // Created Window")

	ren, err := sdl.CreateRenderer(win, -1, 0)

	if err != nil {
		log.Fatalln("Game // Error while creating renderer")
		log.Panic(err)
	}

	ren.SetDrawColor(255, 255, 255, 255)

	log.Println("Game // Created Renderer")

	log.Println("Game // Init Success")

	window = win
	renderer = ren

	input.InitJoystick()

	running = true

	currentScene.Enter()
}
Пример #17
0
func (d *Display) init() (err error) {
	err = sdl.Init(sdl.INIT_VIDEO)
	if err != nil {
		return err
	}

	d.window, err = sdl.CreateWindow("anna", sdl.WINDOWPOS_UNDEFINED, sdl.WINDOWPOS_UNDEFINED, 1400, 500, sdl.WINDOW_SHOWN)
	if err != nil {
		return err
	}

	d.renderer, err = sdl.CreateRenderer(d.window, -1, sdl.RENDERER_ACCELERATED)
	if err != nil {
		return err
	}

	return nil
}
Пример #18
0
func Run(cont func()) {
	runtime.LockOSThread()
	defer panic("shouldn't exit")

	sdl.Init(sdl.INIT_EVERYTHING)
	ttf.Init()

	err := mix.OpenAudio(mix.DEFAULT_FREQUENCY, mix.DEFAULT_FORMAT, 2, 4096)
	if err != nil {
		fmt.Printf("Could not open audio: %v\n", err)
	}

	go cont()

	for {
		(<-execChan)()
	}
}
Пример #19
0
func main() {
	if err := sdl.Init(sdl.INIT_AUDIO); err != nil {
		log.Println(err)
		return
	}
	defer sdl.Quit()

	spec := &sdl.AudioSpec{
		Freq:     sampleHz,
		Format:   sdl.AUDIO_U8,
		Channels: 2,
		Samples:  sampleHz,
		Callback: sdl.AudioCallback(C.SineWave),
	}
	sdl.OpenAudio(spec, nil)
	sdl.PauseAudio(false)
	time.Sleep(1 * time.Second)
}
Пример #20
0
// The programs main function
func main() {
	// ---- This is the start of Owen's graphics setup code ----

	// First we have to initalise the SDL library, before we can use it
	sdl.Init(sdl.INIT_EVERYTHING)
	// defer is a go keyword and a special feature.
	// This means that go will automatically call the function sdl.Quit() before
	// the program exits for us. We don't have to remember to put this at the end!
	defer sdl.Quit()

	// if you want to change these try 800 for the width and 600 for the height
	windowWidth = 1024
	windowHeight = 768

	// Now we have to create the window we want to use.
	// We need to tell the SDL library how big to make the window of the correct
	// size - that's what the bit in the brackets does
	window = createWindow(windowWidth, windowHeight)
	// automatically destroy the window when the program finishes
	defer window.Destroy()
	// Now we have a window we need to create a renderer so we can draw into
	// it. In this case we want to use the first graphics card that supports faster
	// drawing
	renderer = createRenderer(window)
	// automatically destroy the renderer when the program exits.
	defer renderer.Destroy()

	// Set a black i.e. RGBA (0,0,0,0) background colour and clear the window
	renderer.SetDrawColor(0, 0, 0, 0)
	renderer.Clear()
	// ---- This is the end of Owen's graphics setup code ----

	// defer any cleanup actions
	defer cleanup()
	// initialise the games variables.
	initialise()
	// render everything initially so that we can see the game before it starts
	render()
	// now start the main game loop of the game.
	gameMainLoop()
}
Пример #21
0
func GetJs() (*sdl.Joystick, error) {
	sdl.Init(sdl.INIT_JOYSTICK)
	numJs := sdl.NumJoysticks()
	if numJs == 0 {
		return nil, errors.New("Joystick missing.")
	}

	jsIdx := -1
	for i := 0; i < numJs; i++ {
		if sdl.JoystickNameForIndex(i) == "T.Flight Hotas X" {
			jsIdx = i
			break
		}
	}

	if jsIdx == -1 {
		return nil, errors.New("Unsuported joystick!")
	}

	return sdl.JoystickOpen(jsIdx), nil
}
Пример #22
0
func main() {
	var (
		err     error
		window  *sdl.Window
		context sdl.GLContext
	)

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

	sdl.GL_SetAttribute(sdl.GL_CONTEXT_PROFILE_MASK, sdl.GL_CONTEXT_PROFILE_COMPATIBILITY)

	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)

	if err = sdl.GL_MakeCurrent(window, context); err != nil {
		panic(err)
	}

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

	sdl.GL_SetSwapInterval(1)

	printGLInfo()
	setupGL()
	windowLoop(window)
}
Пример #23
0
func main() {
	var (
		err     error
		window  *sdl.Window
		context sdl.GLContext
	)

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

	sdl.GL_SetAttribute(sdl.GL_CONTEXT_MAJOR_VERSION, 3)
	sdl.GL_SetAttribute(sdl.GL_CONTEXT_MINOR_VERSION, 2)
	sdl.GL_SetAttribute(sdl.GL_CONTEXT_PROFILE_MASK, sdl.GL_CONTEXT_PROFILE_CORE)

	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)

	if err = sdl.GL_MakeCurrent(window, context); err != nil {
		panic(err)
	}

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

	printGLInfo()
	cameraMatrixUniform := setupGL()
	windowLoop(window, cameraMatrixUniform)
}
Пример #24
0
func main() {
	sdl.Init(sdl.INIT_EVERYTHING)

	window, err := sdl.CreateWindow("test", sdl.WINDOWPOS_UNDEFINED, sdl.WINDOWPOS_UNDEFINED,
		800, 600, sdl.WINDOW_SHOWN)
	if err != nil {
		panic(err)
	}
	defer window.Destroy()

	surface, err := window.GetSurface()
	if err != nil {
		panic(err)
	}

	rect := sdl.Rect{0, 0, 200, 200}
	surface.FillRect(&rect, 0xffff0000)
	window.UpdateSurface()

	sdl.Delay(1000)
	sdl.Quit()
}
Пример #25
0
func TestTexture(t *testing.T) {
	if sdl.Init(sdl.INIT_EVERYTHING) != 0 {
		panic(sdl.GetError())
	}
	defer sdl.Quit()

	window := sdl.CreateWindow("test", 0, 0, 320, 200, sdl.WINDOW_HIDDEN|sdl.WINDOW_OPENGL)
	defer window.Destroy()

	sdl.GL_SetAttribute(sdl.GL_CONTEXT_PROFILE_MASK, sdl.GL_CONTEXT_PROFILE_ES)
	sdl.GL_SetAttribute(sdl.GL_CONTEXT_MAJOR_VERSION, 2)
	sdl.GL_SetAttribute(sdl.GL_CONTEXT_MINOR_VERSION, 0)

	glctx := sdl.GL_CreateContext(window)
	defer sdl.GL_DeleteContext(glctx)

	tex := gl.CreateTexture()
	gl.BindTexture(gl.TEXTURE_2D, tex)
	if !gl.IsTexture(tex) {
		t.Error(tex, "is not a texture")
	}
}
Пример #26
0
func main() {
	var window *sdl.Window
	var renderer *sdl.Renderer

	sdl.Init(sdl.INIT_EVERYTHING)

	window = createWindow(winTitle, winHeight, winWidth)
	defer window.Destroy()

	renderer = createRenderer(window)
	defer renderer.Destroy()

	var secTickChan = time.Tick(time.Second)
	var events = &Events{}
	var fps = 0
	var view = NewGameView()

	for {
		// Pump events
		events.GetEvents()

		// Pass events and renderer to view
		view.Render(renderer, events)

		// This structure logs the fps
		select {
		case <-secTickChan:
			log.Println("fps:", fps)
			fps = 0
		default:
			fps++
		}

		// Delay the next frame rendering to free up CPU
		sdl.Delay(13)
	}
}
Пример #27
0
// Creates a window with the configuration of it's receiver
func (w *Window) Create() {

	// Initialize and create the window
	sdl.Init(sdl.INIT_EVERYTHING)
	window, err := sdl.CreateWindow(
		w.WindowName,
		sdl.WINDOWPOS_UNDEFINED,
		sdl.WINDOWPOS_UNDEFINED,
		w.Width,
		w.Height,
		sdl.WINDOW_SHOWN)

	if err != nil {
		panic(err)
	}

	// If successful, set the window
	w.Window = window

	// Grab the window surface
	w.surface, err = window.GetSurface()
	if err != nil {
		panic(err)
	}

	// Create and attach a backbuffer to work with
	w.Backbuffer = backbuffer.New(
		w.Width,
		w.Height,
		w.surface.BytesPerPixel(),
		w.surface.Pixels())

	// Fill background black and update
	w.Backbuffer.Fill(0xFF000000)
	w.Update()
}
Пример #28
0
func (d *Display) Reset() {
	var err error

	if err = sdl.Init(sdl.INIT_EVERYTHING); err != nil {
		log.Panicln(err)
	}

	d.Window, err = sdl.CreateWindow("go chip8", sdl.WINDOWPOS_UNDEFINED, sdl.WINDOWPOS_UNDEFINED, X*10, Y*10, sdl.WINDOW_SHOWN)
	if err != nil {
		log.Panicln(err)
	}

	d.Surface, err = d.Window.GetSurface()
	if err != nil {
		log.Panicln(err)
	}

	d.Cells = make([][]byte, Y)
	for i := range d.Cells {
		d.Cells[i] = make([]byte, X)
	}

	d.Clear()
}
Пример #29
0
func main() {
	sdl.Init(sdl.INIT_VIDEO)
	defer sdl.Quit()
	window, err := sdl.CreateWindow("Tank", sdl.WINDOWPOS_UNDEFINED, sdl.WINDOWPOS_UNDEFINED, windowWidth, windowHeight, 0)
	if err != nil {
		panic(err)
	}
	defer window.Destroy()

mainloop:
	for {
		for event := sdl.PollEvent(); event != nil; event = sdl.PollEvent() {
			switch event.(type) {
			case *sdl.QuitEvent:
				break mainloop
			}
		}
		windowSurface, _ := window.GetSurface()
		windowSurface.FillRect(nil, sdl.MapRGB(windowSurface.Format, 0, 0, 0))

		window.UpdateSurface()
		sdl.Delay(1000)
	}
}
Пример #30
0
Файл: game.go Проект: doddo/gfx
// Start the game and enter the event loop
func (g *Game) Start() {
	g.playing = true
	g.gameArea = newGameArea()
	r := sdl.Rect{650, 150, 300, 300}
	g.scoreBoard = &scoreBoard{area: &r}

	//g.scoreBoard.area = &r
	//TODO: make these values take them from somewhere
	//g.gameArea.color = 0x000dd0c
	// get some settings
	g.settings = &misc.GfxSettings{}
	running := true
	// Random seed
	//s1 := rand.NewSource(time.Now().UnixNano())

	sdl.Init(sdl.INIT_EVERYTHING)

	g.window, err = sdl.CreateWindow("test", sdl.WINDOWPOS_UNDEFINED, sdl.WINDOWPOS_UNDEFINED,
		1200, 800, sdl.WINDOW_SHOWN)
	if err != nil {
		panic(err)
	}

	// Draw the nice background
	g.drawGameArea()
	g.drawScoreBoard()

	// freshen the screen
	//g.updateScreen()

	fmt.Println("it works")

	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.KeyDownEvent:
				if t.Keysym.Sym == 27 { // Quit on ESC, fix this better later
					running = false
				} else {
					g.handleKeyStroke(t.Keysym)
				}

			case *sdl.KeyUpEvent:
				// handleKeyPress(false, t.Keysym)
			}
		}
		g.tick()
	}

	sdl.Quit()

}