// Initialization boilerplate
func initialize(config *configuration) *renderer {
var bgImage, appSurface *sdl.Surface
if sdl.Init(sdl.INIT_VIDEO) != 0 {
panic(sdl.GetError())
}
if ttf.Init() != 0 {
panic(sdl.GetError())
}
font := ttf.OpenFont(flag.Arg(0), 12)
if font == nil {
panic(sdl.GetError())
}
sdl.EnableUNICODE(1)
if config.fullscreen {
flags := sdl.FULLSCREEN
appSurface = sdl.SetVideoMode(640, 480, 32, uint32(flags))
sdl.ShowCursor(sdl.DISABLE)
} else {
appSurface = sdl.SetVideoMode(640, 480, 32, 0)
}
if config.bgImage != "" {
bgImage = sdl.Load(config.bgImage)
}
sdlrenderer = clingon.NewSDLRenderer(sdl.CreateRGBSurface(sdl.SRCALPHA, int(config.consoleW), int(config.consoleH), 32, 0, 0, 0, 0), font)
sdlrenderer.GetSurface().SetAlpha(sdl.SRCALPHA, 0xaa)
return &renderer{
config: config,
appSurface: appSurface,
sdlRenderer: sdlrenderer,
bgImageSurface: bgImage,
}
}
func main() {
log.SetFlags(0)
var resourcePath string
{
GOPATH := os.Getenv("GOPATH")
if GOPATH == "" {
log.Fatal("No such environment variable: GOPATH")
}
for _, gopath := range strings.Split(GOPATH, ":") {
a := gopath + "/src/github.com/0xe2-0x9a-0x9b/Go-SDL/sdl-test"
_, err := os.Stat(a)
if err == nil {
resourcePath = a
break
}
}
if resourcePath == "" {
log.Fatal("Failed to find resource directory")
}
}
var joy *sdl.Joystick
if sdl.Init(sdl.INIT_EVERYTHING) != 0 {
log.Fatal(sdl.GetError())
}
if ttf.Init() != 0 {
log.Fatal(sdl.GetError())
}
if sdl.NumJoysticks() > 0 {
// Open joystick
joy = sdl.JoystickOpen(0)
if joy != nil {
println("Opened Joystick 0")
println("Name: ", sdl.JoystickName(0))
println("Number of Axes: ", joy.NumAxes())
println("Number of Buttons: ", joy.NumButtons())
println("Number of Balls: ", joy.NumBalls())
} else {
println("Couldn't open Joystick!")
}
}
if mixer.OpenAudio(mixer.DEFAULT_FREQUENCY, mixer.DEFAULT_FORMAT,
mixer.DEFAULT_CHANNELS, 4096) != 0 {
log.Fatal(sdl.GetError())
}
var screen = sdl.SetVideoMode(640, 480, 32, sdl.RESIZABLE)
if screen == nil {
log.Fatal(sdl.GetError())
}
var video_info = sdl.GetVideoInfo()
println("HW_available = ", video_info.HW_available)
println("WM_available = ", video_info.WM_available)
println("Video_mem = ", video_info.Video_mem, "kb")
sdl.EnableUNICODE(1)
sdl.WM_SetCaption("Go-SDL SDL Test", "")
image := sdl.Load(resourcePath + "/test.png")
if image == nil {
log.Fatal(sdl.GetError())
}
sdl.WM_SetIcon(image, nil)
running := true
font := ttf.OpenFont(resourcePath+"/Fontin Sans.otf", 72)
if font == nil {
log.Fatal(sdl.GetError())
}
font.SetStyle(ttf.STYLE_UNDERLINE)
white := sdl.Color{255, 255, 255, 0}
text := ttf.RenderText_Blended(font, "Test (with music)", white)
music := mixer.LoadMUS(resourcePath + "/test.ogg")
sound := mixer.LoadWAV(resourcePath + "/sound.ogg")
if music == nil || sound == nil {
log.Fatal(sdl.GetError())
}
music.PlayMusic(-1)
if sdl.GetKeyName(270) != "[+]" {
log.Fatal("GetKeyName broken")
}
worm_in := make(chan Point)
draw := make(chan Point, 64)
var out chan Point
var in chan Point
out = worm_in
in = out
out = make(chan Point)
go worm(in, out, draw)
ticker := time.NewTicker(time.Second / 50) // 50 Hz
// Note: The following SDL code is highly ineffective.
// It is eating too much CPU. If you intend to use Go-SDL,
// you should to do better than this.
for running {
select {
case <-ticker.C:
screen.FillRect(nil, 0x302019)
screen.Blit(&sdl.Rect{0, 0, 0, 0}, text, nil)
loop:
for {
select {
case p := <-draw:
screen.Blit(&sdl.Rect{int16(p.x), int16(p.y), 0, 0}, image, nil)
case <-out:
default:
break loop
}
}
var p Point
sdl.GetMouseState(&p.x, &p.y)
worm_in <- p
screen.Flip()
case _event := <-sdl.Events:
switch e := _event.(type) {
case sdl.QuitEvent:
running = false
case sdl.KeyboardEvent:
println("")
println(e.Keysym.Sym, ": ", sdl.GetKeyName(sdl.Key(e.Keysym.Sym)))
if e.Keysym.Sym == sdl.K_ESCAPE {
running = false
}
fmt.Printf("%04x ", e.Type)
for i := 0; i < len(e.Pad0); i++ {
fmt.Printf("%02x ", e.Pad0[i])
}
println()
fmt.Printf("Type: %02x Which: %02x State: %02x Pad: %02x\n", e.Type, e.Which, e.State, e.Pad0[0])
fmt.Printf("Scancode: %02x Sym: %08x Mod: %04x Unicode: %04x\n", e.Keysym.Scancode, e.Keysym.Sym, e.Keysym.Mod, e.Keysym.Unicode)
case sdl.MouseButtonEvent:
if e.Type == sdl.MOUSEBUTTONDOWN {
println("Click:", e.X, e.Y)
in = out
out = make(chan Point)
go worm(in, out, draw)
sound.PlayChannel(-1, 0)
}
case sdl.JoyAxisEvent:
println("Joystick Axis Event ->", "Type", e.Type, "Axis:", e.Axis, " Value:", e.Value, "Which:", e.Which)
case sdl.JoyButtonEvent:
println("Joystick Button Event ->", e.Button)
println("State of button", e.Button, "->", joy.GetButton(int(e.Button)))
case sdl.ResizeEvent:
println("resize screen ", e.W, e.H)
screen = sdl.SetVideoMode(int(e.W), int(e.H), 32, sdl.RESIZABLE)
if screen == nil {
log.Fatal(sdl.GetError())
}
}
}
}
// Close if opened
if sdl.JoystickOpened(0) > 0 {
joy.Close()
}
image.Free()
music.Free()
font.Close()
ttf.Quit()
sdl.Quit()
}
func main() {
var p Playfield = NewPlayfield(StandardWidth, StandardHeight)
if sdl.Init(sdl.INIT_EVERYTHING) != 0 {
panic(sdl.GetError())
}
var screen = sdl.SetVideoMode(p.width*PixPerBrick,
p.height*PixPerBrick, 32, sdl.RESIZABLE)
if screen == nil {
panic(sdl.GetError())
}
//var video_info = sdl.GetVideoInfo()
sdl.EnableUNICODE(1)
sdl.WM_SetCaption("YATI:Go", "")
dropTicker := time.NewTicker(time.Second / 2.0)
var curPiece *Piece = nil
score := 0
mainloop:
for {
select {
case <-dropTicker.C:
if curPiece == nil {
curPiece = makeNewTet()
curPiece.pos.x = p.width/2 - 2
if !curPiece.move(&p, 0, 0) {
fmt.Println("Failed placement test")
break mainloop
}
} else {
// advance piece
if !curPiece.move(&p, 0, 1) {
p.place(curPiece)
// remove lines
score += p.removeCompletedLines()
fmt.Println(score)
timeDiv := 2.0 + float64(score/10)/4.0
duration := float64(time.Second) / timeDiv
dropTicker = time.NewTicker(time.Duration(duration))
curPiece = nil
}
}
case _event := <-sdl.Events:
switch e := _event.(type) {
case sdl.QuitEvent:
break mainloop
case sdl.KeyboardEvent:
//key := sdl.GetKeyName(sdl.Key(e.Keysym.Sym))
//println(e.Keysym.Sym, ": ", sdl.GetKeyName(sdl.Key(e.Keysym.Sym)))
if e.Type == sdl.KEYDOWN {
switch e.Keysym.Sym {
case sdl.K_ESCAPE:
break mainloop
case sdl.K_w:
curPiece.rotate(&p, -1)
case sdl.K_a:
curPiece.move(&p, -1, 0)
case sdl.K_d:
curPiece.move(&p, 1, 0)
case sdl.K_s:
//curPiece.rotate(&p,1)
fallthrough
case sdl.K_SPACE:
// turn on drop mode
dropTicker = time.NewTicker(time.Second / 60.0)
}
}
}
}
p.render(screen)
curPiece.render(screen)
screen.Flip()
}
//fmt.Println("----")
//p.removeLine(5)
//p.print()
}
func main() {
runtime.LockOSThread()
if sdl.Init(sdl.INIT_EVERYTHING) != 0 {
log.Fatal(sdl.GetError())
}
var screen = sdl.SetVideoMode(screenWidth, screenHeight, 32, sdl.OPENGL|sdl.HWSURFACE|sdl.GL_DOUBLEBUFFER|sdl.FULLSCREEN)
if screen == nil {
log.Fatal(sdl.GetError())
}
sdl.WM_SetCaption("Lecture Hall Games", "")
sdl.EnableUNICODE(1)
if gl.Init() != 0 {
log.Fatal("could not initialize OpenGL")
}
gl.Viewport(0, 0, int(screen.W), int(screen.H))
gl.ClearColor(1, 1, 1, 0)
gl.Clear(gl.COLOR_BUFFER_BIT)
gl.MatrixMode(gl.PROJECTION)
gl.LoadIdentity()
gl.Ortho(0, float64(screen.W), float64(screen.H), 0, -1.0, 1.0)
gl.Disable(gl.LIGHTING)
gl.Disable(gl.DEPTH_TEST)
gl.TexEnvi(gl.TEXTURE_ENV, gl.TEXTURE_ENV_MODE, gl.MODULATE)
if mixer.OpenAudio(mixer.DEFAULT_FREQUENCY, mixer.DEFAULT_FORMAT,
mixer.DEFAULT_CHANNELS, 4096) != 0 {
log.Fatal(sdl.GetError())
}
if ttf.Init() != 0 {
log.Fatal(sdl.GetError())
}
if p, err := build.Default.Import(basePkg, "", build.FindOnly); err == nil {
os.Chdir(p.Dir)
}
var err error
rand.Seed(time.Now().UnixNano())
levelDir := fmt.Sprintf("data/levels/demolevel%d", 3+rand.Intn(numberLevels))
//carsDir := fmt.Sprintf(" data/cars/car%d/", 1+rand.Intn(numberCars))
if game, err = NewRacer(levelDir); err != nil {
log.Fatal(err)
}
go func() {
listen, err := net.Listen("tcp", ":8001")
if err != nil {
log.Fatal(err)
}
for {
conn, err := listen.Accept()
if err != nil {
log.Println(err)
continue
}
go handleConnection(conn)
}
}()
running := true
last := time.Now()
for running {
select {
case event := <-sdl.Events:
switch e := event.(type) {
case sdl.QuitEvent:
running = false
case sdl.ResizeEvent:
screen = sdl.SetVideoMode(int(e.W), int(e.H), 32, sdl.RESIZABLE)
case sdl.KeyboardEvent:
if e.Type == sdl.KEYDOWN {
if e.Keysym.Sym == sdl.K_ESCAPE {
running = false
} else {
game.KeyPressed(e.Keysym)
}
}
}
default:
}
current := time.Now()
t := current.Sub(last)
last = current
mu.Lock()
game.Update(t)
game.Render(screen)
mu.Unlock()
sdl.GL_SwapBuffers()
}
sdl.Quit()
}