Beispiel #1
0
func (v *CursesView) initCursesColors() (err error) {
	if v.colored = cur.HasColors(); !v.colored {
		return
	}
	if err := cur.StartColor(); err != nil {
		log.Print(err)
	}
	if err := cur.UseDefaultColors(); err != nil {
		log.Print(err)
	}

	colorMap := []int16{
		cur.C_WHITE,
		cur.C_BLUE,
		cur.C_GREEN,
		cur.C_YELLOW,
		cur.C_CYAN,
		cur.C_RED,
	}
	for i, c := range colorMap {

		if e := cur.InitPair(int16(i), c, cur.C_BLACK); e != nil {
			log.Printf("InitPair(%d, %v, %v) failed: %v", i, colorMap[i], cur.C_BLACK, e)
		}
		if e := cur.InitPair(int16(i+len(colorMap)), cur.C_BLACK, colorMap[i]); e != nil {
			log.Printf("InitPair(%d, %v, %v) failed: %v", i, colorMap[i], cur.C_BLACK, e)
		}
	}
	return
}
Beispiel #2
0
func main() {
	stdscr, _ := gc.Init()
	defer gc.End()

	gc.StartColor()
	gc.CBreak(true)
	gc.Echo(true)
	stdscr.Keypad(true)
	stdscr.Print("Hit 'tab' to cycle through windows, 'q' to quit")

	gc.InitPair(1, gc.C_RED, gc.C_BLACK)
	gc.InitPair(2, gc.C_GREEN, gc.C_BLACK)
	gc.InitPair(3, gc.C_BLUE, gc.C_BLACK)
	gc.InitPair(4, gc.C_CYAN, gc.C_BLACK)

	var panels [3]*gc.Panel
	y, x := 4, 10

	for i := 0; i < 3; i++ {
		h, w := 10, 40
		title := "Window Number %d"

		window, _ := gc.NewWindow(h, w, y+(i*4), x+(i*10))
		window.Box(0, 0)
		window.MoveAddChar(2, 0, gc.ACS_LTEE)
		window.HLine(2, 1, gc.ACS_HLINE, w-2)
		window.MoveAddChar(2, w-1, gc.ACS_RTEE)
		window.ColorOn(int16(i + 1))
		window.MovePrintf(1, (w/2)-(len(title)/2), title, i+1)
		window.ColorOff(int16(i + 1))
		panels[i] = gc.NewPanel(window)

	}

	active := 2

	for {
		gc.UpdatePanels()
		gc.Update()

		switch stdscr.GetChar() {
		case 'q':
			return
		case gc.KEY_TAB:
			active += 1
			if active > 2 {
				active = 0
			}
			panels[active].Top()
		}
	}
}
Beispiel #3
0
func main() {
	stdscr, err := gc.Init()
	if err != nil {
		log.Fatal("init:", err)
	}
	defer gc.End()

	// HasColors can be used to determine whether the current terminal
	// has the capability of using colours. You could then chose whether or
	// not to use some other mechanism, like using A_REVERSE, instead
	if !gc.HasColors() {
		log.Fatal("Example requires a colour capable terminal")
	}

	// Must be called after Init but before using any colour related functions
	if err := gc.StartColor(); err != nil {
		log.Fatal(err)
	}

	gc.Echo(false)

	// Initialize a colour pair. Should only fail if an improper pair value
	// is given
	if err := gc.InitPair(1, gc.C_RED, gc.C_WHITE); err != nil {
		log.Fatal("InitPair failed: ", err)
	}
	gc.InitPair(2, gc.C_BLACK, gc.C_CYAN)

	stdscr.Println("Type any key to proceed and again to exit")

	// An example of trying to set an invalid color pair
	err = gc.InitPair(-1, gc.C_BLACK, gc.C_CYAN)
	stdscr.Println("An intentional error:", err)

	stdscr.Keypad(true)
	stdscr.MovePrint(12, 30, "Hello, World!!!")
	stdscr.Refresh()
	stdscr.GetChar()
	// Note that background doesn't just accept colours but will fill
	// any blank positions with the supplied character too. Note that newly
	// added text with spaces in it will have the blanks converted to the fill
	// character, if given
	stdscr.SetBackground(gc.Char('*') | gc.ColorPair(2))
	// ColorOn/Off is a shortcut to calling AttrOn/Off(gc.ColorPair(pair))
	stdscr.ColorOn(1)
	stdscr.MovePrint(13, 30, "Hello, World in Color!!!")
	stdscr.ColorOff(1)
	stdscr.Refresh()
	stdscr.GetChar()
}
Beispiel #4
0
//sets up the initial configuration of curses. Keeps code in main cleaner.
func configCurses(stdscr *gc.Window) {
	if !gc.HasColors() {
		log.Fatal("Example requires a colour capable terminal")
	}
	if err := gc.StartColor(); err != nil {
		log.Fatal("Starting Colors failed:", err)
	}
	gc.Echo(false)

	if err := gc.InitPair(1, gc.C_RED, gc.C_BLACK); err != nil {
		log.Fatal("InitPair failed: ", err)
	}
	gc.InitPair(2, gc.C_BLUE, gc.C_BLACK)
	gc.InitPair(3, gc.C_GREEN, gc.C_BLACK)
	gc.InitPair(4, gc.C_YELLOW, gc.C_BLACK)
	gc.InitPair(5, gc.C_CYAN, gc.C_BLACK)
	gc.InitPair(6, gc.C_MAGENTA, gc.C_WHITE)
	gc.InitPair(7, gc.C_MAGENTA, gc.C_BLACK)

	//set background color to black
	stdscr.SetBackground(gc.Char(' ') | gc.ColorPair(0))

	stdscr.Keypad(true)
	gc.Cursor(1)
	gc.CBreak(true)
	stdscr.Clear()
}
Beispiel #5
0
func initColors() {
	gc.StartColor()
	gc.InitPair(game.BLUE, gc.C_BLUE, gc.C_BLUE)
	gc.InitPair(game.CYAN, gc.C_CYAN, gc.C_CYAN)
	gc.InitPair(game.GREEN, gc.C_GREEN, gc.C_GREEN)
	gc.InitPair(game.MAGENTA, gc.C_MAGENTA, gc.C_MAGENTA)
	gc.InitPair(game.RED, gc.C_RED, gc.C_RED)
	gc.InitPair(game.WHITE, gc.C_WHITE, gc.C_WHITE)
	gc.InitPair(game.YELLOW, gc.C_YELLOW, gc.C_YELLOW)
}
Beispiel #6
0
func main() {
	stdscr, err := gc.Init()
	if err != nil {
		log.Fatal(err)
	}
	defer gc.End()

	gc.StartColor()
	gc.Echo(false)
	gc.Raw(true)

	var colours = []int16{gc.C_BLACK, gc.C_BLUE, gc.C_CYAN, gc.C_GREEN,
		gc.C_MAGENTA, gc.C_RED, gc.C_WHITE, gc.C_YELLOW}
	var attributes = []struct {
		attr gc.Char
		text string
	}{
		{gc.A_NORMAL, "normal"},
		{gc.A_STANDOUT, "standout"},
		{gc.A_UNDERLINE | gc.A_BOLD, "underline"},
		{gc.A_REVERSE, "reverse"},
		{gc.A_BLINK, "blink"},
		{gc.A_DIM, "dim"},
		{gc.A_BOLD, "bold"},
	}
	stdscr.MovePrint(0, 0, "Normal terminal colors: ")
	for i, c := range colours {
		gc.InitPair(int16(i), c, c)
		stdscr.ColorOn(int16(i))
		stdscr.AddChar(' ')
		stdscr.ColorOff(int16(i))
	}
	stdscr.MovePrint(1, 0, "Bold terminal colors:   ")
	stdscr.AttrOn(gc.A_BLINK)
	for i, _ := range colours {
		stdscr.ColorOn(int16(i))
		stdscr.AddChar(' ')
		stdscr.ColorOff(int16(i))
	}
	stdscr.AttrOff(gc.A_BLINK)
	stdscr.Move(2, 0)
	for _, a := range attributes {
		stdscr.AttrOn(a.attr)
		stdscr.Println(a.text)
		stdscr.AttrOff(a.attr)
	}
	stdscr.GetChar()
}
Beispiel #7
0
func main() {
	gc.SlkInit(gc.SLK_323)
	scr, err := gc.Init()
	if err != nil {
		log.Fatal("INIT:", err)
	}
	defer gc.End()

	gc.StartColor()
	gc.InitPair(SOFTKEYS, gc.C_YELLOW, gc.C_BLUE)

	scr.Print("Type any key to exit...")
	labels := [...]string{"ONE", "TWO", "THREE", "FOUR", "FIVE", "SIX", "SEVEN",
		"EIGHT"}
	for i := range labels {
		gc.SlkSet(i+1, labels[i], gc.SLK_CENTER)
	}
	gc.SlkColor(SOFTKEYS)
	gc.SlkNoutRefresh()
	scr.Refresh()
	scr.GetChar()
}
Beispiel #8
0
func (ui *NcurseUi) initColors() {
	if goncurses.HasColors() {
		err := goncurses.StartColor()
		HandleErr(err)

		goncurses.UseDefaultColors()

		//Main window
		goncurses.InitPair(1, goncurses.C_WHITE, -1)
		goncurses.InitPair(2, goncurses.C_RED, -1)
		goncurses.InitPair(3, goncurses.C_GREEN, -1)
		goncurses.InitPair(4, goncurses.C_CYAN, -1)

		//Title colors
		goncurses.InitPair(10, goncurses.C_BLACK, goncurses.C_BLUE)

		//Menu colors
		goncurses.InitPair(20, goncurses.C_YELLOW, -1)
	}
}
Beispiel #9
0
func main() {
	stdscr, err := gc.Init()
	if err != nil {
		log.Fatal("init:", err)
	}
	defer gc.End()

	gc.StartColor()
	gc.Raw(true)
	gc.Echo(false)
	gc.Cursor(0)
	stdscr.Keypad(true)
	gc.InitPair(1, gc.C_RED, gc.C_BLACK)
	gc.InitPair(2, gc.C_GREEN, gc.C_BLACK)
	gc.InitPair(3, gc.C_MAGENTA, gc.C_BLACK)

	// build the menu items
	menu_items := []string{
		"Choice 1",
		"Choice 2",
		"Choice 3",
		"Choice 4",
		"Choice 5",
		"Exit"}
	items := make([]*gc.MenuItem, len(menu_items))
	for i, val := range menu_items {
		items[i], _ = gc.NewItem(val, "")
		defer items[i].Free()

		if i == 2 || i == 4 {
			items[i].Selectable(false)
		}
	}

	// create the menu
	menu, _ := gc.NewMenu(items)
	defer menu.Free()

	y, _ := stdscr.MaxYX()
	stdscr.MovePrint(y-3, 0, "Use up/down arrows to move; 'q' to exit")
	stdscr.Refresh()

	menu.SetForeground(gc.ColorPair(1) | gc.A_REVERSE)
	menu.SetBackground(gc.ColorPair(2) | gc.A_BOLD)
	menu.Grey(gc.ColorPair(3) | gc.A_BOLD)

	menu.Post()
	defer menu.UnPost()

	for {
		gc.Update()
		ch := stdscr.GetChar()
		switch ch {
		case ' ':
			menu.Driver(gc.REQ_TOGGLE)
		case 'q':
			return
		case gc.KEY_RETURN:
			stdscr.Move(20, 0)
			stdscr.ClearToEOL()
			stdscr.Printf("Item selected is: %s", menu.Current(nil).Name())
			menu.PositionCursor()
		default:
			menu.Driver(gc.DriverActions[ch])
		}
	}
}
Beispiel #10
0
func main() {
	f, err := os.Create("err.log")
	if err != nil {
		log.Fatal(err)
	}
	defer f.Close()

	log.SetOutput(f)

	var stdscr *gc.Window
	stdscr, err = gc.Init()
	if err != nil {
		log.Println("Init:", err)
	}
	defer gc.End()

	rand.Seed(time.Now().Unix())
	gc.StartColor()
	gc.Cursor(0)
	gc.Echo(false)
	gc.HalfDelay(1)

	gc.InitPair(1, gc.C_WHITE, gc.C_BLACK)
	gc.InitPair(2, gc.C_YELLOW, gc.C_BLACK)
	gc.InitPair(3, gc.C_MAGENTA, gc.C_BLACK)
	gc.InitPair(4, gc.C_RED, gc.C_BLACK)

	gc.InitPair(5, gc.C_BLUE, gc.C_BLACK)
	gc.InitPair(6, gc.C_GREEN, gc.C_BLACK)

	lines, cols := stdscr.MaxYX()
	pl, pc := lines, cols*3

	ship := newShip(lines/2, 5)
	objects = append(objects, ship)

	field := genStarfield(pl, pc)
	text := stdscr.Duplicate()

	c := time.NewTicker(time.Second / 2)
	c2 := time.NewTicker(time.Second / 16)
	px := 0

loop:
	for {
		text.MovePrintf(0, 0, "Life: [%-5s]", lifeToText(ship.life))
		stdscr.Erase()
		stdscr.Copy(field.Window, 0, px, 0, 0, lines-1, cols-1, true)
		drawObjects(stdscr)
		stdscr.Overlay(text)
		stdscr.Refresh()
		select {
		case <-c.C:
			spawnAsteroid(stdscr.MaxYX())
			if px+cols >= pc {
				break loop
			}
			px++
		case <-c2.C:
			updateObjects(stdscr.MaxYX())
			drawObjects(stdscr)
		default:
			if !handleInput(stdscr, ship) || ship.Expired(-1, -1) {
				break loop
			}
		}
	}
	msg := "Game Over"
	end, err := gc.NewWindow(5, len(msg)+4, (lines/2)-2, (cols-len(msg))/2)
	if err != nil {
		log.Fatal("game over:", err)
	}
	end.MovePrint(2, 2, msg)
	end.Box(gc.ACS_VLINE, gc.ACS_HLINE)
	end.Refresh()
	gc.Nap(2000)
}
Beispiel #11
0
func main() {
	stdscr, _ := gc.Init()
	defer gc.End()

	gc.Echo(false)
	gc.CBreak(true)
	gc.StartColor()
	stdscr.Keypad(true)

	gc.InitPair(1, gc.C_WHITE, gc.C_BLUE)
	gc.InitPair(2, gc.C_YELLOW, gc.C_BLUE)

	fields := make([]*gc.Field, 2)
	fields[0], _ = gc.NewField(1, 10, 4, 18, 0, 0)
	defer fields[0].Free()
	fields[0].SetForeground(gc.ColorPair(1))
	fields[0].SetBackground(gc.ColorPair(2) | gc.A_UNDERLINE | gc.A_BOLD)
	fields[0].SetOptionsOff(gc.FO_AUTOSKIP)

	fields[1], _ = gc.NewField(1, 10, 6, 18, 0, 0)
	defer fields[1].Free()
	fields[1].SetForeground(gc.ColorPair(1))
	fields[1].SetBackground(gc.A_UNDERLINE)
	fields[1].SetOptionsOff(gc.FO_AUTOSKIP)
	fields[1].SetPad('*')

	form, _ := gc.NewForm(fields)
	form.Post()
	defer form.UnPost()
	defer form.Free()
	stdscr.Refresh()

	fields[0].SetBuffer("Buffer 0")

	stdscr.AttrOn(gc.ColorPair(2) | gc.A_BOLD)
	stdscr.MovePrint(4, 10, "Value 1:")
	stdscr.AttrOff(gc.ColorPair(2) | gc.A_BOLD)
	stdscr.MovePrint(6, 10, "Value 2:")
	stdscr.Refresh()

	form.Driver(gc.REQ_FIRST_FIELD)

	ch := stdscr.GetChar()
	for ch != 'q' {
		switch ch {
		case gc.KEY_DOWN, gc.KEY_TAB:
			form.Driver(gc.REQ_NEXT_FIELD)
			form.Driver(gc.REQ_END_LINE)
		case gc.KEY_UP:
			form.Driver(gc.REQ_PREV_FIELD)
			form.Driver(gc.REQ_END_LINE)
		case gc.KEY_BACKSPACE:
			form.Driver(gc.REQ_CLR_FIELD)
		default:
			form.Driver(ch)
		}
		ch = stdscr.GetChar()
	}
	stdscr.MovePrint(20, 0, fields[1].Buffer())
	stdscr.GetChar()
}
Beispiel #12
0
func main() {
	stdscr, _ := gc.Init()
	defer gc.End()

	gc.StartColor()
	gc.Raw(true)
	gc.Echo(false)
	gc.Cursor(0)
	stdscr.Keypad(true)
	gc.InitPair(1, gc.C_RED, gc.C_BLACK)

	// build the menu items
	menu_items := []string{"Choice 1", "Choice 2", "Choice 3", "Choice 4",
		"Exit"}
	items := make([]*gc.MenuItem, len(menu_items))
	for i, val := range menu_items {
		items[i], _ = gc.NewItem(val, "")
		defer items[i].Free()
	}

	// create the menu
	menu, _ := gc.NewMenu(items)
	defer menu.Free()

	menuwin, _ := gc.NewWindow(10, 40, 4, 14)
	menuwin.Keypad(true)

	menu.SetWindow(menuwin)
	dwin := menuwin.Derived(6, 38, 3, 1)
	menu.SubWindow(dwin)
	menu.Mark(" * ")

	// Print centered menu title
	y, x := menuwin.MaxYX()
	title := "My Menu"
	menuwin.Box(0, 0)
	menuwin.ColorOn(1)
	menuwin.MovePrint(1, (x/2)-(len(title)/2), title)
	menuwin.ColorOff(1)
	menuwin.MoveAddChar(2, 0, gc.ACS_LTEE)
	menuwin.HLine(2, 1, gc.ACS_HLINE, x-3)
	menuwin.MoveAddChar(2, x-2, gc.ACS_RTEE)

	y, x = stdscr.MaxYX()
	stdscr.MovePrint(y-2, 1, "'q' to exit")
	stdscr.Refresh()

	menu.Post()
	defer menu.UnPost()
	menuwin.Refresh()

	for {
		gc.Update()
		ch := menuwin.GetChar()

		switch ch {
		case 'q':
			return
		case gc.KEY_DOWN:
			menu.Driver(gc.REQ_DOWN)
		case gc.KEY_UP:
			menu.Driver(gc.REQ_UP)
		}
	}
}
Beispiel #13
0
func main() {
	stdscr, _ := gc.Init()
	defer gc.End()

	gc.StartColor()
	gc.Raw(true)
	gc.Echo(false)
	gc.Cursor(0)
	stdscr.Keypad(true)
	gc.InitPair(1, gc.C_RED, gc.C_BLACK)
	gc.InitPair(2, gc.C_CYAN, gc.C_BLACK)

	// build the menu items
	menu_items := []string{
		"Choice 1",
		"Choice 2",
		"Choice 3",
		"Choice 4",
		"Choice 5",
		"Choice 6",
		"Choice 7",
		"Choice 8",
		"Choice 9",
		"Choice 10",
		"Exit"}
	items := make([]*gc.MenuItem, len(menu_items))
	for i, val := range menu_items {
		items[i], _ = gc.NewItem(val, "")
		defer items[i].Free()
	}

	// create the menu
	menu, _ := gc.NewMenu(items)
	defer menu.Free()

	menuwin, _ := gc.NewWindow(HEIGHT, WIDTH, 4, 14)
	menuwin.Keypad(true)

	menu.SetWindow(menuwin)
	dwin := menuwin.Derived(6, 38, 3, 1)
	menu.SubWindow(dwin)
	menu.Format(5, 1)
	menu.Mark(" * ")

	// Print centered menu title
	title := "My Menu"
	menuwin.Box(0, 0)
	menuwin.ColorOn(1)
	menuwin.MovePrint(1, (WIDTH/2)-(len(title)/2), title)
	menuwin.ColorOff(1)
	menuwin.MoveAddChar(2, 0, gc.ACS_LTEE)
	menuwin.HLine(2, 1, gc.ACS_HLINE, WIDTH-2)
	menuwin.MoveAddChar(2, WIDTH-1, gc.ACS_RTEE)

	y, _ := stdscr.MaxYX()
	stdscr.ColorOn(2)
	stdscr.MovePrint(y-3, 1,
		"Use up/down arrows or page up/down to navigate. 'q' to exit")
	stdscr.ColorOff(2)
	stdscr.Refresh()

	menu.Post()
	defer menu.UnPost()
	menuwin.Refresh()

	for {
		gc.Update()
		if ch := menuwin.GetChar(); ch == 'q' {
			return
		} else {
			menu.Driver(gc.DriverActions[ch])
		}
	}
}
Beispiel #14
0
func main() {
	stdscr, err := gc.Init()
	if err != nil {
		log.Fatal("init", err)
	}
	defer gc.End()

	if err := gc.StartColor(); err != nil {
		log.Fatal(err)
	}

	lines, cols := stdscr.MaxYX()

	gc.Raw(true)   // turn on raw "uncooked" input
	gc.Echo(false) // turn echoing of typed characters off
	gc.Cursor(0)   // hide cursor
	stdscr.Timeout(50)
	stdscr.Keypad(true) // allow keypad input

	gc.InitPair(1, gc.C_YELLOW, gc.C_BLACK)
	gc.InitPair(2, gc.C_RED, gc.C_BLACK)
	gc.InitPair(3, gc.C_GREEN, gc.C_BLACK)
	gc.InitPair(4, gc.C_BLUE, gc.C_BLACK)
	gc.InitPair(5, gc.C_WHITE, gc.C_BLACK)
	gc.InitPair(6, gc.C_BLACK, gc.C_BLACK)
	gc.InitPair(7, gc.C_MAGENTA, gc.C_BLACK)

	stdscr.SetBackground(gc.ColorPair(3))

	rand.Seed(time.Now().UTC().UnixNano())

	state := State{Money: 150}

	var build *Thing

	things := make([]Thing, 0, 20)
	var toUpdate int64 = 0
	lastTimestamp := int64(time.Nanosecond) * time.Now().UTC().UnixNano() / int64(time.Millisecond)

	frames := make(map[string][][]string)

	count := rand.Intn(15) + 25

	for i := 0; i < count; i++ {
		for {
			var kind Kind
			var pop int
			r := rand.Intn(2)

			switch r {
			case 0:
				kind = &SmallHouse{Frames: &frames}
				pop = 10
			case 1:
				kind = &House{Frames: &frames}
				pop = 40
			}

			house := &Thing{2 + rand.Intn(cols-8), 2 + rand.Intn(lines-8), kind}

			overlap := false
			for _, thing := range things {
				if house.Overlap(&thing) {
					overlap = true
					break
				}
			}

			if !overlap {
				things = append(things, *house)
				state.Population += pop
				break
			}
		}
	}

	var overlap bool
	var price float32
	showInfo := true

	for {
		now := int64(time.Nanosecond) * time.Now().UTC().UnixNano() / int64(time.Millisecond)
		delta := now - lastTimestamp
		lastTimestamp = now
		toUpdate -= delta

		c := stdscr.GetChar()

		switch c {
		case 'q':
			break
		case 'a':
			if build != nil && build.X > 0 {
				build.X--
			}
		case 'd':
			if build != nil && build.X+build.GetSize().X < cols {
				build.X++
			}
		case 'w':
			if build != nil && build.Y > 0 {
				build.Y--
			}
		case 's':
			if build != nil && build.Y+build.GetSize().Y < lines {
				build.Y++
			}
		case ' ':
			if build != nil && !overlap && state.Money >= price {
				things = append(things, *build)
				state.Money -= price
				build = nil
			}
		case '1':
			if state.Money >= 100 {
				build = &Thing{cols / 2, lines / 2, &Shop{Frames: &frames}}
				price = 100
			}
		case '2':
			if state.Money >= 600 {
				build = &Thing{cols / 2, lines / 2, &Factory{Frames: &frames}}
				price = 600
			}
		case '3':
			if state.Money >= 1100 {
				build = &Thing{cols / 2, lines / 2, &BigFactory{Frames: &frames}}
				price = 1100
			}
		case '4':
			if state.Money >= 2000 {
				build = &Thing{cols / 2, lines / 2, &Office{Frames: &frames}}
				price = 2000
			}
		}

		if c == 'q' {
			break
		}

		stdscr.Erase()

		if state.Population == 0 {
			stdscr.AttrOn(gc.ColorPair(3) | gc.A_BOLD)
			stdscr.MovePrint(lines/2, cols/2-4, "You won!")
			continue
		}

		if showInfo && c != 0 {
			showInfo = false
		}

		if showInfo {
			info := `
  __  __         _____       _     _ _
 |  \/  |       / ____|     | |   | | |
 | \  / |_ __  | |  __  ___ | | __| | |__   ___ _ __ __ _
 | |\/| | '__| | | |_ |/ _ \| |/ _  | '_ \ / _ \ '__/ _  |
 | |  | | |_   | |__| | (_) | | (_| | |_) |  __/ | | (_| |
 |_|  |_|_(_)   \_____|\___/|_|\__,_|_.__/ \___|_|  \__, |
                                                     __/ |
                                                     |___/



			You are Mr. Goldberg, a famous and well respected businessman.
			You're looking to expand your business to a new city.
			It looks promising, but has one serious problem - too many
			people living in it, getting in the way!
			Maybe if you build some factories near their homes they will
			eventually move out and stop bothering you?

			Instructions:
			 * earn money to build stuff
			 * pollution will cause people to move out
			 * you win when city population reaches 0!
			 * 1/2/3/4 to choose building, WASD to move, SPACE to build it, Q to quit

			                        [ any key to start ]
			`

			stdscr.AttrOn(gc.ColorPair(5) | gc.A_BOLD)
			for i, s := range strings.Split(info, "\n") {
				stdscr.MovePrint(lines/2+i-16, cols/2-30, strings.Trim(s, "\t"))
			}
			continue
		}

		overlap = false
		if toUpdate <= 0 {
			state.MoneyDelta = 0
			state.PollutionDelta = 0
		}

		for _, thing := range things {
			stdscr.AttrOn(thing.GetColor())
			thing.Draw(stdscr)
			stdscr.AttrOff(thing.GetColor())
			if toUpdate <= 0 {
				thing.Update(&state)
			}
			if build != nil && build.Overlap(&thing) {
				overlap = true
			}
		}

		if build != nil {
			if overlap {
				stdscr.AttrOn(gc.ColorPair(2))
			} else {
				stdscr.AttrOn(gc.ColorPair(7))
			}
			build.Draw(stdscr)
		}

		if toUpdate <= 0 {
			toUpdate = 1000
		}

		stdscr.AttrOn(gc.ColorPair(1) | gc.A_BOLD)
		stdscr.MovePrintf(1, 1, "Cash:       $%.2f (+$%.2f/s)", state.Money, state.MoneyDelta)
		stdscr.AttrOff(gc.ColorPair(1) | gc.A_BOLD)
		stdscr.AttrOn(gc.ColorPair(3) | gc.A_BOLD)
		stdscr.MovePrintf(2, 1, "Population: %d", state.Population)
		stdscr.AttrOff(gc.ColorPair(3) | gc.A_BOLD)
		stdscr.AttrOn(gc.ColorPair(2) | gc.A_BOLD)
		stdscr.MovePrintf(3, 1, "Pollution:  %d (+%d/s)", state.Pollution, state.PollutionDelta)
		stdscr.AttrOff(gc.ColorPair(2) | gc.A_BOLD)

		if state.Money >= 100 {
			stdscr.AttrOn(gc.ColorPair(5) | gc.A_BOLD)
		} else {
			stdscr.AttrOn(gc.ColorPair(6) | gc.A_BOLD)
		}

		stdscr.MovePrint(1, cols-50, "1: Shop ($100) [2$/s]")

		if state.Money >= 600 {
			stdscr.AttrOn(gc.ColorPair(5) | gc.A_BOLD)
		} else {
			stdscr.AttrOn(gc.ColorPair(6) | gc.A_BOLD)
		}

		stdscr.MovePrint(3, cols-50, "2: Factory ($600) [5$/s, 1 pollution/s]")

		if state.Money >= 1100 {
			stdscr.AttrOn(gc.ColorPair(5) | gc.A_BOLD)
		} else {
			stdscr.AttrOn(gc.ColorPair(6) | gc.A_BOLD)
		}

		stdscr.MovePrint(5, cols-50, "3: Big factory ($1100) [10$/s, 3 pollution/s]")
		stdscr.AttrOff(gc.A_BOLD)

		if state.Money >= 2000 {
			stdscr.AttrOn(gc.ColorPair(5) | gc.A_BOLD)
		} else {
			stdscr.AttrOn(gc.ColorPair(6) | gc.A_BOLD)
		}

		stdscr.MovePrint(7, cols-50, "4: Office ($2000) [+20% money generated]")
		stdscr.AttrOff(gc.A_BOLD)

		stdscr.Refresh()
	}

	stdscr.GetChar()
}