v/examples/gg/fire.v

// Use `v -d show_fps run examples/gg/fire.v` to show a fire effect with an FPS counter.
import gg
import rand

const win_width = 800
const win_height = 600
const width = 100
const height = 140
const scale = 4
const palette = [
	gg.rgb(0x07, 0x07, 0x07),
	gg.rgb(0x1f, 0x07, 0x07),
	gg.rgb(0x2f, 0x0f, 0x07),
	gg.rgb(0x47, 0x0f, 0x07),
	gg.rgb(0x57, 0x17, 0x07),
	gg.rgb(0x67, 0x1f, 0x07),
	gg.rgb(0x77, 0x1f, 0x07),
	gg.rgb(0x8f, 0x27, 0x07),
	gg.rgb(0x9f, 0x2f, 0x07),
	gg.rgb(0xaf, 0x3f, 0x07),
	gg.rgb(0xbf, 0x47, 0x07),
	gg.rgb(0xc7, 0x47, 0x07),
	gg.rgb(0xdf, 0x4f, 0x07),
	gg.rgb(0xdf, 0x57, 0x07),
	gg.rgb(0xdf, 0x57, 0x07),
	gg.rgb(0xd7, 0x5f, 0x07),
	gg.rgb(0xd7, 0x5f, 0x07),
	gg.rgb(0xd7, 0x67, 0x0f),
	gg.rgb(0xcf, 0x6f, 0x0f),
	gg.rgb(0xcf, 0x77, 0x0f),
	gg.rgb(0xcf, 0x7f, 0x0f),
	gg.rgb(0xcf, 0x87, 0x17),
	gg.rgb(0xc7, 0x87, 0x17),
	gg.rgb(0xc7, 0x8f, 0x17),
	gg.rgb(0xc7, 0x97, 0x1f),
	gg.rgb(0xbf, 0x9f, 0x1f),
	gg.rgb(0xbf, 0x9f, 0x1f),
	gg.rgb(0xbf, 0xa7, 0x27),
	gg.rgb(0xbf, 0xa7, 0x27),
	gg.rgb(0xbf, 0xaf, 0x2f),
	gg.rgb(0xb7, 0xaf, 0x2f),
	gg.rgb(0xb7, 0xb7, 0x2f),
	gg.rgb(0xb7, 0xb7, 0x37),
	gg.rgb(0xcf, 0xcf, 0x6f),
	gg.rgb(0xdf, 0xdf, 0x9f),
	gg.rgb(0xef, 0xef, 0xc7),
	gg.rgb(0xff, 0xff, 0xff),
]!

struct App {
mut:
	gg    &gg.Context = unsafe { nil }
	buf   [][]int
	dying bool
	tiles int
}

fn main() {
	mut app := &App{
		buf: [][]int{len: height - 1, init: []int{len: width}}
	}
	app.buf << []int{len: width, init: 36} // white fire base

	app.gg = gg.new_context(
		event_fn:     event
		frame_fn:     frame
		init_fn:      retile
		window_title: 'Fire Animation'
		user_data:    app
		bg_color:     palette[0]
		width:        win_width
		height:       win_height
	)
	app.gg.run()
}

fn retile(mut app App) {
	size := app.gg.window_size()
	app.tiles = size.width / (width * scale) + 1
}

fn (mut app App) draw() {
	size := app.gg.window_size()
	for t in 0 .. app.tiles {
		app.gg.begin()
		for y, row in app.buf {
			for x, i in row {
				app.gg.draw_square_filled(t * width * scale + x * scale,
					(size.height - height * scale) + y * scale, scale, palette[i])
			}
		}
		app.gg.end(
			how: if t == 0 { .clear } else { .passthru }
		)
		// one pass per tile to avoid sgl vertex limit
	}
}

@[direct_array_access]
fn (mut app App) tick() {
	for x in 0 .. width {
		for y in 1 .. height {
			if app.buf[y][x] > 0 {
				r := rand.intn(4) or { panic('failed to generate random number') }
				xn := ((x - r + 1) % width + width) % width
				app.buf[y - 1][xn] = app.buf[y][x] - r % 2
			} else {
				app.buf[y - 1][x] = 0
			}
		}
	}
	if app.dying {
		for x in 0 .. width {
			y := height - 1
			app.buf[y][x] -= rand.intn(4) or { panic('failed to generate random number') }
			if app.buf[y][x] < 0 {
				app.buf[y][x] = 0
			}
		}
	}
}

fn event(event &gg.Event, mut app App) {
	match event.typ {
		.key_up {
			match event.key_code {
				.space {
					if app.dying {
						app.dying = false
						app.buf[height - 1] = []int{len: width, init: 36}
					} else {
						app.dying = true
					}
				}
				else {}
			}
		}
		.resized {
			retile(mut app)
		}
		else {}
	}
}

fn frame(mut app App) {
	app.draw()
	app.tick()
}