From 5e539d668febc4ebcef70163fc43d0d6a1172114 Mon Sep 17 00:00:00 2001
From: crumblingstatue <radiantstatue@gmail.com>
Date: Sat, 1 Apr 2023 23:43:46 +0200
Subject: [PATCH] Render some tiles

---
 res/tiles.png   | Bin 4356 -> 4921 bytes
 src/game.rs     |  37 ++++++++++++++++++++++++++++++---
 src/graphics.rs |  21 +++++++++++++++----
 src/math.rs     |  14 +++++++++++++
 src/world.rs    |  53 +++++++++++++++++++++++++++++++++++++++++++++---
 5 files changed, 115 insertions(+), 10 deletions(-)

diff --git a/res/tiles.png b/res/tiles.png
index 114cafa39167938b642208ee9d01ed9b56f16f74..21d6e7332e1276e9cd0a2f46541e99ec852e40b9 100644
GIT binary patch
delta 970
zcmZos+Nm}{xn7vT)5S5QV$PepCv)!@NU#N1dhpvx7VrjpR~7iaJGga68-wLiuIC9H
z3T~$-2%2}kXWVz@gmTxVr@xOrefjq7+w80tfB*hn`Sd3v149CfeUv!^0|SGGKO=}@
zTL2;%m_4)@_SozfvlOfPT)5jbR+^cCL1Fv+jqLku_SgH>|NGbX@8Oi>?K!O*;^)uz
z731T%9lV=Ye*5k4)vw>3j5D}yfB%`?C3yx02aR0}6O=D3zrke)lI=E-*_NJnIO?~?
z;<Asa`_3Ca&kCJm=*7su;IUDIVadLi`kA^RXXkI_i2eNYkXg^aw0&PRdZ)Ec+sUz^
z{NFXjJ=e<^85rvSMv5?0asI#j#p20!zWa#|GLbK<FC4bLr(Lq8f-TDaHv_|gpDzB4
zE8Yg~SSh=wO3x)GRR8ZSXK4lohQ3w%cpqFXV;A5%{X+E*GXq16>sKZR|6m>l28INY
zNG^u(>ec)V3=HAHwJZ!Tx3wLPFJ*K({J;NVJp;pmSvsr?hkvcFmp*36e>;eYfuUM#
zHz<_mDP8z3RC1{HQS`gW`<H4zCU1G2pICSA**>|iH<=k29_ey1^dI^k$;Gm@rBRzF
zd1-TmKI??Yinn{WzCCs5QMVmC1H(5Je?|}9|EgjfZ)_9V7BlwEs!!*;_BsAXWZ!3*
zjiD@=*B2SC`D)F;aA4ZedX9!WMg3wgZ2z<uZ7F^IzxrkSR<kEM4PW$hj;*PU|0K88
zm+{7>!<(5H7`9AZ%8(Fs;F5>pj%j=Utr0A^ey-kLeE+oH#qZ|c-@?PdkTA<glp(9N
zUh&y&$zKmW4E$mrtaCf?Hgn?MD~Bc}i7+r2_=+xLcv94M!Mo1z``%-Zy7$`FSMS}*
z&cN^@{*zLJF311JKj#aw+$&*bV90r0#BxCN+tlza8P8wU-p{(r$iVR64qq>W#@3_p
zXVSMW-LkO#TintAXUg@jiZL)W7)SRoctl>@|K(AA;*8gcg4+yw-syU5|Nd9>h|a0$
zk8RQ=F5Q3STXVy_zl@=xgolB_pv{$W!PEM(x@t!2GS?qL@45xE-%6<FoPD_Y*tVLs
z-TB=+`9BwKy~V=7@J0K!6oaNR`?Vu`V)^%HOIBTTs_*^$ZOOCJWg?7j+G0H=YZ(|0
z7~bS!sD5a_&0@l?N7ZjOs(!uHCwRn%eMO~x)%<x33=9HYdJHm^hv!@W>CZc|PwL|=
zMh1o=;VwOfEiuvzRZBD&85riAT$szixOpO@7eD`l`04@=Q2tSP@jp8~V)8^rX)z0y
X0*~y+n!j=;gCsm%{an^LB{Ts5DzUId

delta 397
zcmdm~)}k~)xnAJ3r;B4q#hkZyPxBr!5O8pG5}u=UF*eJq++)rPCaw)E+dinDJ2yx9
z(AD#C={L8%t(DBU|2_4|Z$<_Ng{Idp>=_ss7`CW`NCyTc5XBN8!f@^O-jkad7#JL)
zZ!#wAy{muzy7KRK?|G~Y3=FqU@iB;fVPIe|Sg*ohv8$e+fq~)qWEKYNzYGiv1$O(u
zW-ylUGq~|EFfc6G|BmrM2O|Rm!<TSXh8tJe85kOpi`gOes4`ew18F}#jfLU(PeulY
z2Q`xzK4hE6D=;uHH2f6lXP6@QT^wXg!k%Z-8FtBov>p2_>A=9iz;PfP#8XIZc%}?u
z9H;<W%mUKN;J{GN$}s&uBLl+$nMn)*n^u(n1nE7a$jKn~73|Eb?-&gDK>Ch{>N3<=
zTPlD!2O@4VKA7*iXCufc32keJh$GAl3<vhC>fOAN*@J)b0cLseFP|9Q;tU;L-AuLv
OY4>#Xb6Mw<&;$VFpn9<Y

diff --git a/src/game.rs b/src/game.rs
index 8e18d3a..b9d93cf 100644
--- a/src/game.rs
+++ b/src/game.rs
@@ -1,6 +1,11 @@
-use sfml::graphics::{RenderTarget, RenderWindow, Sprite};
+use sfml::graphics::{Rect, RenderTarget, RenderWindow, Sprite, Transformable};
 
-use crate::{math::WorldPos, res::Res, world::World};
+use crate::{
+    graphics::{ScreenPos, NATIVE_RESOLUTION},
+    math::{WorldPos, WorldPosScalar, TILE_SIZE},
+    res::Res,
+    world::{TilePos, World},
+};
 
 pub struct GameState {
     camera_offset: WorldPos,
@@ -8,7 +13,33 @@ pub struct GameState {
 }
 impl GameState {
     pub(crate) fn draw_world(&mut self, rw: &mut RenderWindow, res: &Res) {
-        rw.draw(&Sprite::with_texture(&res.tile_atlas));
+        let mut s = Sprite::with_texture(&res.tile_atlas);
+        for_each_tile(self.camera_offset, |tp, sp| {
+            let tile = self.world.tile_at_mut(tp);
+            s.set_texture_rect(Rect::new(tile.id as i32 * 32, 0, 32, 32));
+            s.set_position(sp.to_sf_vec());
+            rw.draw(&s);
+        });
+    }
+}
+
+fn for_each_tile(camera_offset: WorldPos, mut f: impl FnMut(TilePos, ScreenPos)) {
+    for y in (camera_offset.y..camera_offset.y + NATIVE_RESOLUTION.h as WorldPosScalar).step_by(32)
+    {
+        for x in
+            (camera_offset.x..camera_offset.x + NATIVE_RESOLUTION.w as WorldPosScalar).step_by(32)
+        {
+            f(
+                TilePos {
+                    x: x / 32,
+                    y: y / 32,
+                },
+                ScreenPos {
+                    x: (x - camera_offset.x) as i16,
+                    y: (y - camera_offset.y) as i16,
+                },
+            )
+        }
     }
 }
 
diff --git a/src/graphics.rs b/src/graphics.rs
index 88598d1..480b24a 100644
--- a/src/graphics.rs
+++ b/src/graphics.rs
@@ -1,12 +1,13 @@
 use sfml::{
     graphics::RenderWindow,
+    system::Vector2f,
     window::{ContextSettings, Style, VideoMode},
 };
 use sfml_xt::graphics::RenderWindowExt;
 
-struct ScreenRes {
-    w: u16,
-    h: u16,
+pub struct ScreenRes {
+    pub w: u16,
+    pub h: u16,
 }
 
 impl ScreenRes {
@@ -19,7 +20,19 @@ impl ScreenRes {
     }
 }
 
-const NATIVE_RESOLUTION: ScreenRes = ScreenRes { w: 640, h: 360 };
+// We assume this game won't be played above 32767*32767 resolution
+pub struct ScreenPos {
+    pub x: i16,
+    pub y: i16,
+}
+
+impl ScreenPos {
+    pub fn to_sf_vec(&self) -> Vector2f {
+        Vector2f::new(self.x.into(), self.y.into())
+    }
+}
+
+pub const NATIVE_RESOLUTION: ScreenRes = ScreenRes { w: 960, h: 540 };
 
 pub fn make_window() -> RenderWindow {
     let mut rw = RenderWindow::new(
diff --git a/src/math.rs b/src/math.rs
index ba7a38b..58a8849 100644
--- a/src/math.rs
+++ b/src/math.rs
@@ -1,6 +1,20 @@
+use crate::world::TilePos;
+
 pub type WorldPosScalar = i32;
 
+#[derive(Clone, Copy)]
 pub struct WorldPos {
     pub x: WorldPosScalar,
     pub y: WorldPosScalar,
 }
+
+impl WorldPos {
+    pub fn tile_pos(&self) -> TilePos {
+        TilePos {
+            x: self.x / TILE_SIZE as i32,
+            y: self.y / TILE_SIZE as i32,
+        }
+    }
+}
+
+pub const TILE_SIZE: u8 = 32;
diff --git a/src/world.rs b/src/world.rs
index c0b28f2..0601c7c 100644
--- a/src/world.rs
+++ b/src/world.rs
@@ -3,13 +3,14 @@ use rand::{thread_rng, Rng};
 
 type ChunkPosScalar = i16;
 
-#[derive(Hash)]
+#[derive(Hash, PartialEq, Eq)]
 struct ChunkPos {
     x: ChunkPosScalar,
     y: ChunkPosScalar,
 }
 
 pub struct World {
+    /// The currently loaded chunks
     chunks: FnvHashMap<ChunkPos, Chunk>,
 }
 
@@ -21,6 +22,48 @@ impl Default for World {
     }
 }
 
+impl World {
+    /// Get mutable access to the tile at `pos`.
+    ///
+    /// Loads or generates the containing chunk if necessary.
+    pub fn tile_at_mut(&mut self, pos: TilePos) -> &mut Tile {
+        let (chk, local) = pos.to_chunk_and_local();
+        let chk = self.chunks.entry(chk).or_insert_with(Chunk::new_rand);
+        chk.at_mut(local)
+    }
+}
+
+pub struct TilePos {
+    pub x: TilePosScalar,
+    pub y: TilePosScalar,
+}
+
+pub struct ChunkLocalTilePos {
+    pub x: ChunkLocalTilePosScalar,
+    pub y: ChunkLocalTilePosScalar,
+}
+
+type ChunkLocalTilePosScalar = i16;
+
+impl TilePos {
+    fn to_chunk_and_local(&self) -> (ChunkPos, ChunkLocalTilePos) {
+        // 0,0 is chunk (0, 0)
+        // -1, -1 is chunk (-1, -1)
+        let chk = ChunkPos {
+            x: (self.x / CHUNK_EXTENT as i32) as i16,
+            y: (self.y / CHUNK_EXTENT as i32) as i16,
+        };
+        let local = ChunkLocalTilePos {
+            x: (self.x % CHUNK_EXTENT as i32) as i16,
+            y: (self.y % CHUNK_EXTENT as i32) as i16,
+        };
+        (chk, local)
+    }
+}
+
+// Need to support at least 8 million tiles long
+type TilePosScalar = i32;
+
 const CHUNK_EXTENT: u16 = 256;
 const CHUNK_N_TILES: usize = CHUNK_EXTENT as usize * CHUNK_EXTENT as usize;
 
@@ -35,15 +78,19 @@ impl Chunk {
         let mut rng = thread_rng();
         let mut tiles = [Tile { id: 0 }; CHUNK_N_TILES];
         for b in &mut tiles {
-            b.id = rng.gen();
+            b.id = rng.gen_range(0..8);
         }
         Self { tiles }
     }
+
+    fn at_mut(&mut self, local: ChunkLocalTilePos) -> &mut Tile {
+        &mut self.tiles[CHUNK_EXTENT as usize * local.y as usize + local.x as usize]
+    }
 }
 
 type TileId = u16;
 
 #[derive(Clone, Copy)]
 pub struct Tile {
-    id: TileId,
+    pub id: TileId,
 }