package level import ( "archive/zip" "encoding/json" "fmt" "math" "sync" "git.kirsle.net/SketchyMaze/doodle/pkg/balance" "git.kirsle.net/SketchyMaze/doodle/pkg/log" "git.kirsle.net/SketchyMaze/doodle/pkg/shmem" "git.kirsle.net/go/render" ) // Chunker is the data structure that manages the chunks of a level, and // provides the API to interact with the pixels using their absolute coordinates // while abstracting away the underlying details. type Chunker struct { // Layer is optional for the caller, levels use only 0 and // doodads use them for frames. When chunks are exported to // zipfile the Layer keeps them from overlapping. Layer int `json:"-"` // internal use only Size uint8 `json:"size"` // A Zipfile reference for new-style levels and doodads which // keep their chunks in external parts of a zip file. Zipfile *zip.Reader `json:"-"` // Chunks, oh boy. // The v1 drawing format had all the chunks in the JSON file. // New drawings write them to zips. Legacy drawings can be converted // simply by loading and resaving: their Chunks loads from JSON and // is committed to zipfile on save. This makes Chunks also a good // cache even when we have a zipfile to fall back on. Chunks ChunkMap `json:"chunks"` chunkMu sync.RWMutex // If we have a zipfile, only keep chunks warm in memory if they // are actively wanted by the game. lastTick uint64 // NOTE: tracks from shmem.Tick chunkRequestsThisTick map[render.Point]interface{} requestsN1 map[render.Point]interface{} // chunks accessed last tick requestsN2 map[render.Point]interface{} // 2 ticks ago (to free soon) chunksToFree map[render.Point]uint64 // chopping block (free after X ticks) ctfMu sync.Mutex // lock for chunksToFree requestMu sync.Mutex // The palette reference from first call to Inflate() pal *Palette } // NewChunker creates a new chunk manager with a given chunk size. func NewChunker(size uint8) *Chunker { return &Chunker{ Size: size, Chunks: ChunkMap{}, chunkRequestsThisTick: map[render.Point]interface{}{}, requestsN1: map[render.Point]interface{}{}, requestsN2: map[render.Point]interface{}{}, chunksToFree: map[render.Point]uint64{}, } } // Inflate iterates over the pixels in the (loaded) chunks and expands any // Sparse Swatches (which have only their palette index, from the file format // on disk) to connect references to the swatches in the palette. func (c *Chunker) Inflate(pal *Palette) error { c.pal = pal c.chunkMu.RLock() defer c.chunkMu.RUnlock() for coord, chunk := range c.Chunks { chunk.Point = coord chunk.Size = c.Size chunk.Inflate(pal) } return nil } // IterViewport returns a channel to iterate every point that exists within // the viewport rect. func (c *Chunker) IterViewport(viewport render.Rect) <-chan Pixel { pipe := make(chan Pixel) go func() { // Get the chunk box coordinates. var ( topLeft = c.ChunkCoordinate(render.NewPoint(viewport.X, viewport.Y)) bottomRight = c.ChunkCoordinate(render.Point{ X: viewport.X + viewport.W, Y: viewport.Y + viewport.H, }) ) for cx := topLeft.X; cx <= bottomRight.X; cx++ { for cy := topLeft.Y; cy <= bottomRight.Y; cy++ { if chunk, ok := c.GetChunk(render.NewPoint(cx, cy)); ok { for px := range chunk.Iter() { // Verify this pixel is also in range. if px.Point().Inside(viewport) { pipe <- px } } } } } close(pipe) }() return pipe } // IterChunks returns a channel to iterate over all chunks in the drawing. func (c *Chunker) IterChunks() <-chan render.Point { var ( pipe = make(chan render.Point) sent = map[render.Point]interface{}{} ) go func() { c.chunkMu.RLock() // Send the chunk coords we have in working memory. // v1 levels: had all their chunks there in their JSON data // v2 levels: chunks are in zipfile, cached ones are here for point := range c.Chunks { sent[point] = nil pipe <- point } c.chunkMu.RUnlock() // If we have a zipfile, send any remaining chunks that are // in colder storage. if c.Zipfile != nil { for _, point := range ChunksInZipfile(c.Zipfile, c.Layer) { if _, ok := sent[point]; ok { continue // Already sent from active memory } pipe <- point } } close(pipe) }() return pipe } /* IterChunksThemselves iterates all chunks in the drawing rather than coords. Note: this will mark every chunk as "touched" this frame, so in a zipfile level will load ALL chunks into memory. */ func (c *Chunker) IterChunksThemselves() <-chan *Chunk { pipe := make(chan *Chunk) go func() { for coord := range c.IterChunks() { if chunk, ok := c.GetChunk(coord); ok { pipe <- chunk } } close(pipe) }() return pipe } // IterCachedChunks iterates ONLY over the chunks currently cached in memory, // e.g. so they can be torn down without loading extra chunks by looping normally. func (c *Chunker) IterCachedChunks() <-chan *Chunk { pipe := make(chan *Chunk) go func() { c.chunkMu.RLock() defer c.chunkMu.RUnlock() for _, chunk := range c.Chunks { pipe <- chunk } close(pipe) }() return pipe } // IterViewportChunks returns a channel to iterate over the Chunk objects that // appear within the viewport rect, instead of the pixels in each chunk. func (c *Chunker) IterViewportChunks(viewport render.Rect) <-chan render.Point { pipe := make(chan render.Point) go func() { var ( sent = make(map[render.Point]interface{}) size = int(c.Size) ) for x := viewport.X; x < viewport.W+size; x += (size / 4) { for y := viewport.Y; y < viewport.H+size; y += (size / 4) { // Constrain this chunksize step to a point within the bounds // of the viewport. This can yield partial chunks on the edges // of the viewport. point := render.NewPoint(x, y) if point.X < viewport.X { point.X = viewport.X } else if point.X > viewport.X+viewport.W { point.X = viewport.X + viewport.W } if point.Y < viewport.Y { point.Y = viewport.Y } else if point.Y > viewport.Y+viewport.H { point.Y = viewport.Y + viewport.H } // Translate to a chunk coordinate, dedupe and send it. coord := c.ChunkCoordinate(render.NewPoint(x, y)) if _, ok := sent[coord]; ok { continue } sent[coord] = nil if _, ok := c.GetChunk(coord); ok { pipe <- coord } } } close(pipe) }() return pipe } // IterPixels returns a channel to iterate over every pixel in the entire // chunker. func (c *Chunker) IterPixels() <-chan Pixel { pipe := make(chan Pixel) go func() { for chunk := range c.IterChunksThemselves() { for px := range chunk.Iter() { pipe <- px } } close(pipe) }() return pipe } // WorldSize returns the bounding coordinates that the Chunker has chunks to // manage: the lowest pixels from the lowest chunks to the highest pixels of // the highest chunks. func (c *Chunker) WorldSize() render.Rect { var ( size = int(c.Size) chunkLowest, chunkHighest = c.Bounds() ) return render.Rect{ X: chunkLowest.X * size, Y: chunkLowest.Y * size, W: (chunkHighest.X * size) + (size - 1), H: (chunkHighest.Y * size) + (size - 1), } } // WorldSizePositive returns the WorldSize anchored to 0,0 with only positive // coordinates. func (c *Chunker) WorldSizePositive() render.Rect { S := c.WorldSize() return render.Rect{ X: 0, Y: 0, W: int(math.Abs(float64(S.X))) + S.W, H: int(math.Abs(float64(S.Y))) + S.H, } } // Bounds returns the boundary points of the lowest and highest chunk which // have any data in them. func (c *Chunker) Bounds() (low, high render.Point) { for coord := range c.IterChunks() { if coord.X < low.X { low.X = coord.X } if coord.Y < low.Y { low.Y = coord.Y } if coord.X > high.X { high.X = coord.X } if coord.Y > high.Y { high.Y = coord.Y } } return low, high } /* GetChunk gets a chunk at a certain position. Returns false if not found. This should be the centralized function to request a Chunk from the Chunker (or IterChunksThemselves). On old-style levels all of the chunks were just in memory as part of the JSON struct, in Zip files we can load/unload them at will from external files. */ func (c *Chunker) GetChunk(p render.Point) (*Chunk, bool) { // It's currently cached in memory? c.chunkMu.RLock() chunk, ok := c.Chunks[p] c.chunkMu.RUnlock() // Was it on the chopping block for garbage collection? c.ctfMu.Lock() delete(c.chunksToFree, p) c.ctfMu.Unlock() if ok { // An empty chunk? We hang onto these until save time to commit // the empty chunk to ZIP. if chunk.Len() == 0 { return nil, false } c.logChunkAccess(p, chunk) // for the LRU cache return chunk, ok } // Hit the zipfile for it. if c.Zipfile != nil { if chunk, err := c.ChunkFromZipfile(p); err == nil { // log.Debug("GetChunk(%s) cache miss, read from zip", p) c.SetChunk(p, chunk) // cache it c.logChunkAccess(p, chunk) // for the LRU cache if c.pal != nil { chunk.Point = p chunk.Size = c.Size chunk.Inflate(c.pal) } return chunk, true } } // Is our chunk cache getting too full? e.g. on full level // sweeps where a whole zip file's worth of chunks are scanned. if balance.ChunkerLRUCacheMax > 0 && len(c.Chunks) > balance.ChunkerLRUCacheMax { log.Error("Chunks in memory (%d) exceeds LRU cache cap of %d, freeing random chunks", len(c.Chunks), balance.ChunkerLRUCacheMax) c.chunkMu.Lock() defer c.chunkMu.Unlock() var ( i = 0 limit = len(c.Chunks) - balance.ChunkerLRUCacheMax ) for coord := range c.Chunks { if i < limit { delete(c.Chunks, coord) } i++ } } return nil, false } // LRU cache for chunks from zipfiles: log which chunks were accessed // this tick, so they can be compared to the tick prior, and then freed // up after that. func (c *Chunker) logChunkAccess(p render.Point, chunk *Chunk) { // Record this point. c.requestMu.Lock() if c.chunkRequestsThisTick == nil { c.chunkRequestsThisTick = map[render.Point]interface{}{} } c.chunkRequestsThisTick[p] = nil c.requestMu.Unlock() } // FreeCaches unloads chunks that have not been requested in 2 frames. // // Only on chunkers that have zipfiles, old-style levels without zips // wouldn't be able to restore their chunks otherwise! Returns -1 if // no Zipfile, otherwise number of chunks freed. func (c *Chunker) FreeCaches() int { if c.Zipfile == nil { return -1 } var thisTick = shmem.Tick // Very first tick this chunker has seen? if c.lastTick == 0 { c.lastTick = thisTick } // A new tick? if (thisTick-c.lastTick)%4 == 0 { c.requestMu.Lock() c.chunkMu.Lock() defer c.requestMu.Unlock() defer c.chunkMu.Unlock() var ( requestsThisTick = c.chunkRequestsThisTick requestsN2 = c.requestsN2 delete_coords = []render.Point{} ) // Chunks requested 2 ticks ago but not this tick, put on the chopping // block to free them later. c.ctfMu.Lock() for coord := range requestsN2 { // Old point not requested recently? if _, ok := requestsThisTick[coord]; !ok { c.chunksToFree[coord] = shmem.Tick + balance.CanvasChunkFreeChoppingBlockTicks } } // From the chopping block, see if scheduled chunks to free are ready. for coord, expireAt := range c.chunksToFree { if shmem.Tick > expireAt { delete_coords = append(delete_coords, coord) } } // Free any eligible chunks NOW. for _, coord := range delete_coords { delete(c.chunksToFree, coord) c.FreeChunk(coord) } c.ctfMu.Unlock() // Rotate the cached ticks and clean the slate. c.requestsN2 = c.requestsN1 c.requestsN1 = requestsThisTick c.chunkRequestsThisTick = map[render.Point]interface{}{} c.lastTick = thisTick return len(delete_coords) } return 0 } // SetChunk writes the chunk into the cache dict and nothing more. // // This function should be the singular writer to the chunk cache. func (c *Chunker) SetChunk(p render.Point, chunk *Chunk) { c.chunkMu.Lock() c.Chunks[p] = chunk c.chunkMu.Unlock() c.logChunkAccess(p, chunk) } // FreeChunk unloads a chunk from active memory for zipfile-backed levels. // // Not thread safe: it is assumed the caller has the lock on c.Chunks. func (c *Chunker) FreeChunk(p render.Point) bool { if c.Zipfile == nil { return false } // If this chunk has been modified since it was last loaded from ZIP, hang onto it // in memory until the next save so we don't lose it. if chunk, ok := c.Chunks[p]; ok { if chunk.IsModified() { return false } // Don't delete empty chunks, hang on until next zipfile save. if chunk, ok := c.Chunks[p]; ok && chunk.Len() == 0 { return false } } delete(c.Chunks, p) return true } // Redraw marks every chunk as dirty and invalidates all their texture caches, // forcing the drawing to re-generate from scratch. func (c *Chunker) Redraw() { for chunk := range c.IterChunksThemselves() { chunk.SetDirty() } } // Prerender visits every chunk and fetches its texture, in order to pre-load // the whole drawing for smooth gameplay rather than chunks lazy rendering as // they enter the screen. func (c *Chunker) Prerender() { for chunk := range c.IterChunksThemselves() { _ = chunk.CachedBitmap(render.Invisible) } } // PrerenderN will pre-render the texture for N number of chunks and then // yield back to the caller. Returns the number of chunks that still need // textures rendered; zero when the last chunk has been prerendered. func (c *Chunker) PrerenderN(n int) (remaining int) { var ( total int // total no. of chunks available totalRendered int // no. of chunks with textures modified int // number modified this call ) for chunk := range c.IterChunksThemselves() { total++ if chunk.bitmap != nil { totalRendered++ continue } if modified < n { _ = chunk.CachedBitmap(render.Invisible) totalRendered++ modified++ } } remaining = total - totalRendered return } // Get a pixel at the given coordinate. Returns the Palette entry for that // pixel or else returns an error if not found. func (c *Chunker) Get(p render.Point) (*Swatch, error) { // Compute the chunk coordinate. coord := c.ChunkCoordinate(p) if chunk, ok := c.GetChunk(coord); ok { return chunk.Get(p) } return nil, fmt.Errorf("no chunk %s exists for point %s", coord, p) } // Set a pixel at the given coordinate. func (c *Chunker) Set(p render.Point, sw *Swatch) error { coord := c.ChunkCoordinate(p) chunk, ok := c.GetChunk(coord) if !ok { chunk = NewChunk() chunk.Point = coord chunk.Size = c.Size c.SetChunk(coord, chunk) } return chunk.Set(p, sw) } // SetRect sets a rectangle of pixels to a color all at once. func (c *Chunker) SetRect(r render.Rect, sw *Swatch) error { var ( xMin = r.X yMin = r.Y xMax = r.X + r.W yMax = r.Y + r.H ) for x := xMin; x < xMax; x++ { for y := yMin; y < yMax; y++ { c.Set(render.NewPoint(x, y), sw) } } return nil } // Delete a pixel at the given coordinate. func (c *Chunker) Delete(p render.Point) error { coord := c.ChunkCoordinate(p) if chunk, ok := c.GetChunk(coord); ok { return chunk.Delete(p) } return fmt.Errorf("no chunk %s exists for point %s", coord, p) } // DeleteRect deletes a rectangle of pixels between two points. // The rect is a relative one with a width and height, and the X,Y values are // an absolute world coordinate. func (c *Chunker) DeleteRect(r render.Rect) error { var ( xMin = r.X yMin = r.Y xMax = r.X + r.W yMax = r.Y + r.H ) for x := xMin; x < xMax; x++ { for y := yMin; y < yMax; y++ { c.Delete(render.NewPoint(x, y)) } } return nil } // ChunkCoordinate computes a chunk coordinate from an absolute coordinate. func (c *Chunker) ChunkCoordinate(abs render.Point) render.Point { if c.Size == 0 { return render.Point{} } size := float64(c.Size) return render.NewPoint( int(math.Floor(float64(abs.X)/size)), int(math.Floor(float64(abs.Y)/size)), ) } // RelativeCoordinate will translate from an absolute world coordinate, into one that // is relative to fit inside of the chunk with the given chunk coordinate and size. // // Example: // // - With 128x128 chunks and a world coordinate of (280,-600) // - The ChunkCoordinate would be (2,-4) which encompasses (256,-512) to (383,-639) // - And relative inside that chunk, the pixel is at (24,) func RelativeCoordinate(abs render.Point, chunkCoord render.Point, chunkSize uint8) render.Point { // Pixel coordinate offset. var ( size = int(chunkSize) offset = render.Point{ X: chunkCoord.X * size, Y: chunkCoord.Y * size, } point = render.Point{ X: abs.X - offset.X, Y: abs.Y - offset.Y, } ) if point.X < 0 || point.Y < 0 { log.Error("RelativeCoordinate: X < 0! abs=%s rel=%s chunk=%s size=%d", abs, point, chunkCoord, chunkSize) log.Error("RelativeCoordinate(2): size=%d offset=%s point=%s", size, offset, point) } return point } // FromRelativeCoordinate is the inverse of RelativeCoordinate. // // With a chunk size of 128 and a relative coordinate like (8, 12), // this function will return the absolute world coordinates based // on your chunk.Point's placement in the level. func FromRelativeCoordinate(rel render.Point, chunkCoord render.Point, chunkSize uint8) render.Point { var ( size = int(chunkSize) offset = render.Point{ X: chunkCoord.X * size, Y: chunkCoord.Y * size, } ) return render.Point{ X: rel.X + offset.X, Y: rel.Y + offset.Y, } } // ChunkMap maps a chunk coordinate to its chunk data. type ChunkMap map[render.Point]*Chunk // MarshalJSON to convert the chunk map to JSON. This is needed for writing so // the JSON encoder knows how to serializes a `map[Point]*Chunk` but the inverse // is not necessary to implement. func (c ChunkMap) MarshalJSON() ([]byte, error) { dict := map[string]*Chunk{} for point, chunk := range c { dict[point.String()] = chunk } out, err := json.Marshal(dict) return out, err }