func main() { // create game object game := tl.NewGame() // create cell cell := tl.Cell{ Bg: tl.ColorGreen, Fg: tl.ColorBlack, Ch: 'v', } // create level filled with cell level := tl.NewBaseLevel(cell) // create body of water level.AddEntity(tl.NewRectangle(10, 10, 50, 20, tl.ColorBlue)) // create player player := Player{ entity: tl.NewEntity(1, 1, 1, 1), level: level, } player.entity.SetCell(0, 0, &tl.Cell{Fg: tl.ColorRed, Ch: '@'}) // add player to level level.AddEntity(&player) // set level of screen game.Screen().SetLevel(level) // start the game game.Start() }
func main() { g := tl.NewGame() sound := CreateSoundCtrl(os.Args[1], true) defer sound.audio.Stop() g.Screen().AddEntity(sound) g.Start() }
func main() { rand.Seed(time.Now().UTC().UnixNano()) game := tl.NewGame() level := tl.NewBaseLevel(tl.Cell{ Bg: tl.ColorWhite, }) for i := 0; i < 4; i++ { TilePos[i] = rand.Intn(4) level.AddEntity(&Tile{ r: tl.NewRectangle(X+TilePos[i]*(TileWidth+BorderWidth), Y-i*(TileHeight+BorderHeight), TileWidth, TileHeight, tl.ColorBlack), }) } level.AddEntity(tl.NewText(X+TileWidth/2-1, Y+TileHeight, "←", tl.ColorBlack, tl.ColorWhite)) level.AddEntity(tl.NewText(X+(TileWidth+BorderWidth)+TileWidth/2-1, Y+TileHeight, "↓", tl.ColorBlack, tl.ColorWhite)) level.AddEntity(tl.NewText(X+2*(TileWidth+BorderWidth)+TileWidth/2-1, Y+TileHeight, "↑", tl.ColorBlack, tl.ColorWhite)) level.AddEntity(tl.NewText(X+3*(TileWidth+BorderWidth)+TileWidth/2-1, Y+TileHeight, "→", tl.ColorBlack, tl.ColorWhite)) level.AddEntity(&RemainingTime{ r: tl.NewText(X+4*(TileWidth+BorderWidth), 0, fmt.Sprintf("%.3f", Time), tl.ColorRed, tl.ColorDefault), s: tl.NewText(0, 0, "0", tl.ColorRed, tl.ColorDefault), t: Time, m: tl.NewText(0, Y+TileHeight+1, "", tl.ColorRed, tl.ColorDefault), e: tl.NewText(X+4*(TileWidth+BorderWidth), Y+TileHeight+1, "", tl.ColorRed, tl.ColorDefault), }) game.Screen().SetLevel(level) game.Start() }
func world() { game := tl.NewGame() level := tl.NewBaseLevel(tl.Cell{ Bg: tl.ColorWhite, Fg: tl.ColorWhite, Ch: '_', }) for i := -1000; i < 1000; i = i + 40 { if i == 0 { continue } for j := -1000; j < 1000; j = j + 40 { level.AddEntity(tl.NewRectangle(i, j, 20, 10, tl.ColorBlue)) } } player := Player{ entity: tl.NewEntity(1, 1, 1, 1), level: level, } player.entity.SetCell(0, 0, &tl.Cell{Fg: tl.ColorBlack, Ch: '옷'}) level.AddEntity(&player) game.Screen().SetLevel(level) go func() { for { player.Tick(tl.Event{}) time.Sleep(200 * time.Millisecond) } }() game.Start() }
func main() { g := tl.NewGame() dat, err := ioutil.ReadFile("lorry.txt") check(err) e := tl.NewEntityFromCanvas(1, 1, tl.CanvasFromString(string(dat))) g.Screen().AddEntity(e) g.Start() }
func main() { game := tl.NewGame() snake := NewSnake(game) game.Screen().SetLevel(snake.Level()) game.Start() }
func main() { g := tl.NewGame() g.Screen().SetFps(30) gamelevel.TheGameState.StartLevel(1, g.Screen()) // g.Screen().AddEntity(tl.NewFpsText(0, 0, tl.ColorRed, tl.ColorDefault, 0.5)) g.Start() }
func main() { if len(os.Args) < 2 { fmt.Println("Please provide a string as first argument") return } g := tl.NewGame() g.AddEntity(&MovingText{ text: tl.NewText(0, 0, os.Args[1], tl.ColorWhite, tl.ColorBlue), }) g.Start() }
func main() { if len(os.Args) < 2 { fmt.Println("Please provide a filepath to open") return } g := tl.NewGame() c := tl.BackgroundCanvasFromFile(os.Args[1]) g.AddEntity(NewImage(c)) g.Start() }
func NewGame() *Game { game := &Game{ level: startLevel, game: tl.NewGame(), board: NewBoard(), status: tl.NewText(19, 0, "", tl.ColorWhite, tl.ColorBlack), } game.player = NewPlayer(game) game.updateStatus() return game }
func main() { g := tl.NewGame() for i := 0; i < 40; i++ { for j := 0; j < 20; j++ { g.Screen().AddEntity(NewClickable(i, j, 1, 1, tl.ColorWhite)) } } g.Start() }
func main() { game := tl.NewGame() // pengo default maze size is 13x15 BuildLevel(game, 15, 17, 0) game.SetDebugOn(false) game.Start() }
func main() { g := tl.NewGame() l := tl.NewBaseLevel(tl.Cell{Bg: 76, Fg: 1}) lmap, err := ioutil.ReadFile("level.json") checkErr(err) parsers := make(map[string]tl.EntityParser) parsers["Player"] = parsePlayer err = tl.LoadLevelFromMap(string(lmap), parsers, l) checkErr(err) g.Screen().SetLevel(l) g.Start() }
func main() { b := NewGame() board := &Board{b, &[13][13]point{}, Point{5, 2}, false, &[]Point{}, false, []*termloop.Text{}} board.build() game := termloop.NewGame() level = termloop.NewBaseLevel(termloop.Cell{}) game.Screen().SetLevel(level) level.AddEntity(board) game.Start() }
func main() { g := tl.NewGame() l := tl.NewBaseLevel(tl.Cell{ Bg: tl.ColorWhite, }) l.AddEntity(&CollRec{ r: tl.NewRectangle(3, 3, 3, 3, tl.ColorRed), move: true, }) l.AddEntity(&CollRec{ r: tl.NewRectangle(7, 4, 3, 3, tl.ColorGreen), move: false, }) g.SetLevel(l) g.Start() }
func Start(comOut chan [boardSize][boardSize]int8, comIn chan [2]int8, comHud chan string) { game := tl.NewGame() level := tl.NewBaseLevel(tl.Cell{ Bg: Bg, Fg: Fg, }) w := newWelcome(game) level.AddEntity(w) b := newBoard(level, game.Screen(), P1, AI2, comIn, comOut, w) level.AddEntity(b) h := newHud(comHud, game.Screen()) b.comHud = comHud game.Screen().AddEntity(h) game.Screen().SetLevel(level) game.Start() }
func main() { g := tl.NewGame() g.Screen().SetFps(60) l := tl.NewBaseLevel(tl.Cell{ Bg: tl.ColorWhite, }) l.AddEntity(&CollRec{ r: tl.NewRectangle(3, 3, 3, 3, tl.ColorRed), move: true, }) l.AddEntity(&CollRec{ r: tl.NewRectangle(7, 4, 3, 3, tl.ColorGreen), move: false, }) g.Screen().SetLevel(l) g.Screen().AddEntity(tl.NewFpsText(0, 0, tl.ColorRed, tl.ColorDefault, 0.5)) g.Start() }
func main() { game := tl.NewGame() level := tl.NewBaseLevel(tl.Cell{ Bg: tl.ColorGreen, Fg: tl.ColorBlack, Ch: 'v', }) level.AddEntity(tl.NewRectangle(10, 10, 50, 20, tl.ColorBlue)) player := Player{ entity: tl.NewEntity(1, 1, 1, 1), level: level, } // Set the character at position (0, 0) on the entity. player.entity.SetCell(0, 0, &tl.Cell{Fg: tl.ColorRed, Ch: '옷'}) level.AddEntity(&player) game.SetLevel(level) game.Start() }
// NewGopherTyper gets the game ready to run. func NewGopherTyper() (*GopherTyper, error) { wReader, err := os.Open("data/words.txt") if err != nil { return nil, err } gt := GopherTyper{} gt.g = tl.NewGame() gt.g.Screen().SetFps(30) gt.wordList = newWordLoader(wReader) gt.intro = newIntroLevel(>, tl.ColorBlack, tl.ColorBlue) gt.game = newGameLevel(>, tl.ColorBlack, tl.ColorRed) gt.store = newStoreLevel(>, tl.ColorBlack, tl.ColorCyan) gt.end = newEndLevel(>, tl.ColorBlack, tl.ColorGreen) gt.stats = newStats() return >, nil }
func main() { game = tl.NewGame() game.SetDebugOn(false) start := tl.NewBaseLevel( tl.Cell{Bg: tl.ColorBlack, Fg: tl.ColorBlack, Ch: 'S'}, ) startText := StartLevel{ tl.NewText(0, 0, startMessage, tl.ColorGreen, tl.ColorBlack), tl.NewText(0, 0, instructions, tl.ColorGreen, tl.ColorBlack), tl.NewText(0, 0, instructions2, tl.ColorGreen, tl.ColorBlack), } start.AddEntity(&startText) game.Screen().SetLevel(start) firstPass = true game.Start() }
func main() { g := tl.NewGame() level := tl.NewBaseLevel(tl.Cell{ Bg: tl.ColorBlack, }) background := tl.NewEntityFromCanvas(-50, -50, *tl.BackgroundCanvasFromFile("artwork/background/forest.png")) level.AddEntity(background) charSelect := "m_mage" var playerCanvases []*tl.Canvas for i := 0; i < 12; i++ { playerCanvases = append(playerCanvases, tl.BackgroundCanvasFromFile(fmt.Sprintf("artwork/sprites/player/%s/%d.png", charSelect, i))) } playerSprite := NewSprite(playerCanvases, 3, 2, 7, 0, 0, 14, 28, level) level.AddEntity(playerSprite) var enemyCanvases []*tl.Canvas for i := 0; i < 12; i++ { enemyCanvases = append(enemyCanvases, tl.BackgroundCanvasFromFile(fmt.Sprintf("artwork/sprites/enemy/flower/%d.png", i))) } enemySprite := NewSprite(enemyCanvases, 3, 2, 7, 70, 15, 14, 28, level) enemySprite.enemy = NewEnemy(5, 10) level.AddEntity(enemySprite) portrait := tl.BackgroundCanvasFromFile(fmt.Sprintf("artwork/sprites/player/%s/portrait.png", charSelect)) var spellCanvases []*tl.Canvas for i := 0; i < 4; i++ { spellCanvases = append(spellCanvases, tl.BackgroundCanvasFromFile(fmt.Sprintf("artwork/spells/fireball/%d.png", i))) } player := NewPlayer(portrait, spellCanvases, playerSprite) playerSprite.player = player level.AddEntity(player) g.Screen().SetLevel(level) g.Start() }
func main() { game = termloop.NewGame() player = NewPlayer() level = termloop.NewBaseLevel(termloop.Cell{Bg: termloop.ColorBlack}) grid = NewGrid(width, height, mineCount) game.SetDebugOn(true) SetupUI() // Add cells to level for x := 0; x < width; x++ { for y := 0; y < height; y++ { level.AddEntity(&grid.cells[x][y]) } } // Add player to level level.AddEntity(&player) game.Screen().SetLevel(level) UpdateUI() GameSetup() game.Start() }
func (d *TermloopDriver) OnInit(c *hachi.Chip8) { // hex keyboard with 16 keys. // 8, 4, 6 and 2 are typically used for directional input. d.keyMap = map[tl.Key]uint16{ tl.KeyTab: hachi.Key0, tl.KeyF2: hachi.Key1, tl.KeyF3: hachi.Key2, tl.KeyF4: hachi.Key3, tl.KeyF5: hachi.Key4, tl.KeyF6: hachi.Key5, tl.KeyF7: hachi.Key6, tl.KeyF8: hachi.Key7, tl.KeyF9: hachi.Key8, tl.KeyF10: hachi.Key9, tl.KeyCtrlA: hachi.KeyA, tl.KeyCtrlB: hachi.KeyB, tl.KeyCtrlC: hachi.KeyC, tl.KeyCtrlD: hachi.KeyD, tl.KeyCtrlE: hachi.KeyE, tl.KeyCtrlF: hachi.KeyF, tl.KeyArrowDown: hachi.Key2, tl.KeyArrowLeft: hachi.Key4, tl.KeyArrowRight: hachi.Key6, tl.KeyArrowUp: hachi.Key8, tl.KeyEnter: hachi.Key5, } // init termloop d.g = tl.NewGame() scr := d.g.Screen() scr.AddEntity(&inputHandler{c, d, make(map[uint16]time.Time)}) scr.AddEntity(tl.NewText(0, 0, "Stack Syscalls", tl.ColorDefault, tl.ColorDefault)) // stack d.stack = make([]*tl.Text, len(c.Stack)) for i := 0; i < len(d.stack); i++ { d.stack[i] = tl.NewText( 0, i+1, "", tl.ColorDefault, tl.ColorDefault) d.g.Screen().AddEntity(d.stack[i]) } // syscall log for i := 0; i < 10; i++ { d.syscalls[i] = tl.NewText( 8, i+1, "", tl.ColorDefault, tl.ColorDefault) d.g.Screen().AddEntity(d.syscalls[i]) } // chip info d.memory = tl.NewText(20, 0, "placeholder", tl.ColorDefault, tl.ColorDefault) scr.AddEntity(d.memory) d.registers = tl.NewText(20, 1, "placeholder", tl.ColorDefault, tl.ColorDefault) scr.AddEntity(d.registers) d.pointersAndTimers = tl.NewText(20, 2, "placeholder", tl.ColorDefault, tl.ColorDefault) scr.AddEntity(d.pointersAndTimers) d.devices = tl.NewText(20, 3, "placeholder", tl.ColorDefault, tl.ColorDefault) scr.AddEntity(d.devices) // screen preview at 20,5 d.screen = make([][]*tl.Rectangle, c.Width) color := tl.ColorWhite // foreground for i := uint8(0); i < c.Width; i++ { d.screen[i] = make([]*tl.Rectangle, c.Height) for j := uint8(0); j < c.Height; j++ { d.screen[i][j] = tl.NewRectangle( 20+int(i), 5+int(j), 1, 1, color, ) } } d.lastScreen = make([]byte, uint16(c.Width)*uint16(c.Height)/8) log.Println("TermloopDriver initialized") }
func main() { g := tl.NewGame() buildLevel(g, 6, 2, 0) g.SetDebugOn(true) g.Start() }