diff --git a/src/l1/anne/some_tests.h b/src/l1/anne/some_tests.h
index 549b3de..e7bde86 100644
--- a/src/l1/anne/some_tests.h
+++ b/src/l1/anne/some_tests.h
@@ -18,6 +18,11 @@ void generate_headers_for_r0_r1_r2_r3() {
             .T = cstr("PlayingSound"), .vec_extended = true
         }, false);
     }
+    mkdir_nofail("l1/eve/r4");
+    {   /* r4 */
+        SpanU8 ns = cstr("r4");
+        generate_eve_span_company_for_primitive(l, ns, cstr("LightSourceState"), true, false);
+    }
     mkdir_nofail("l1/eve/ds_test");
     {     /* This structure is needed for testing purposes only */
         generate_eve_span_company_for_primitive(l, cstr("ds_test"), cstr("RefRBTreeNode_S64"), true, false);
diff --git a/src/l1_5/core/color.h b/src/l1_5/core/color.h
new file mode 100644
index 0000000..a7793ce
--- /dev/null
+++ b/src/l1_5/core/color.h
@@ -0,0 +1,36 @@
+#pragma once
+
+#include "../../../gen/l1/geom.h"
+#include "randomness.h"
+
+// Convert HSV (hue is in degrees; s, v in [0,1]) to RGB (in [0,1]^3)
+static vec3 hsv_to_rgb(float h, float s, float v) {
+    h = fmodf(h, 360.0f);
+    if (h < 0.0f) h += 360.0f;
+    float hf = h / 60.0f;
+    int i = (int)floorf(hf);
+    float f = hf - (float)i;
+    float p = v * (1.0f - s);
+    float q = v * (1.0f - s * f);
+    float t = v * (1.0f - s * (1.0f - f));
+
+    vec3 rgb;
+    switch (i) {
+    case 0: rgb.x = v; rgb.y = t; rgb.z = p; break;
+    case 1: rgb.x = q; rgb.y = v; rgb.z = p; break;
+    case 2: rgb.x = p; rgb.y = v; rgb.z = t; break;
+    case 3: rgb.x = p; rgb.y = q; rgb.z = v; break;
+    case 4: rgb.x = t; rgb.y = p; rgb.z = v; break;
+    default: // i == 5:
+        rgb.x = v; rgb.y = p; rgb.z = q; break;
+    }
+    return rgb;
+}
+
+/* Cute little function that has nothing to do with rainbows */
+vec3 sample_rainbow_color() {
+    float hue = frand01() * 360.0f;
+    float s = 0.95f + 0.05f * frand01(); // in [0.95, 1.0]
+    float v = 0.85f + 0.15f * frand01(); // in [0.85, 1.0]
+    return hsv_to_rgb(hue, s, v);
+}
diff --git a/src/l1_5/core/randomness.h b/src/l1_5/core/randomness.h
new file mode 100644
index 0000000..dd62393
--- /dev/null
+++ b/src/l1_5/core/randomness.h
@@ -0,0 +1,7 @@
+#pragma once
+
+#include "stdlib.h"
+
+float frand01(void) {
+    return (float)rand() / (float)RAND_MAX;
+}
diff --git a/src/l1_5/marie/prim_shape_geom.h b/src/l1_5/marie/prim_shape_geom.h
index 3e2b07d..daade25 100644
--- a/src/l1_5/marie/prim_shape_geom.h
+++ b/src/l1_5/marie/prim_shape_geom.h
@@ -32,9 +32,9 @@ bool marie_intersect_triangle_and_ray(vec3 A, vec3 B, vec3 C, vec3 P, vec3 Q, ve
     if (det_alpha_beta_gamma < 0.0001)
         return false;
     float b_0 = det_delta_beta_gamma / det_alpha_beta_gamma;
-    float b_1 = det_delta_beta_gamma / det_alpha_beta_gamma;
-    float t = det_delta_beta_gamma / det_alpha_beta_gamma;
-    if (b_0 < 0 || b_0 > 1 || b_1 < 0 || b_1 > 1 || t < 0)
+    float b_1 = det_alpha_delta_gamma / det_alpha_beta_gamma;
+    float t = det_alpha_beta_delta / det_alpha_beta_gamma;
+    if (b_0 < 0 || b_1 < 0 || b_0 + b_1 > 1 || t < 0)
         return false;
     *ret = vec3_add_vec3(P, vec3_mul_scal(gamma, -t));
     return true;
diff --git a/src/l2/alice/assets.h b/src/l2/alice/assets.h
index 60c156e..4314762 100644
--- a/src/l2/alice/assets.h
+++ b/src/l2/alice/assets.h
@@ -32,26 +32,18 @@ GenericMeshTopology GenericMeshTopology_clone(const GenericMeshTopology* self) {
     return (GenericMeshTopology){.vertices = VecGenericMeshVertexInc_clone(&self->vertices), .indexes = VecU32_clone(&self->indexes)};
 }
 
+/* non-primitive */
 typedef struct {
-    GenericMeshTopology topology;
     VecU8 diffuse_texture_path;
     VecU8 normal_texture_path;
     VecU8 specular_texture_path;
-} AliceGenericMeshTopology_TexturePaths;
+} AliceGenericMeshTexturePaths;
 
+/* non-primitive */
 typedef struct {
     VecU8 topology_path;
-    VecU8 diffuse_texture_path;
-    VecU8 normal_texture_path;
-    VecU8 specular_texture_path;
-} AliceGenericMeshPath;
-
-void AliceGenericMeshPath_drop(AliceGenericMeshPath self) {
-    VecU8_drop(self.topology_path);
-    VecU8_drop(self.diffuse_texture_path);
-    VecU8_drop(self.normal_texture_path);
-    VecU8_drop(self.specular_texture_path);
-}
+    AliceGenericMeshTexturePaths tex;
+} AliceGenericMeshPaths;
 
 typedef struct {
     mat4 model_t;
diff --git a/src/l2/alice/engine.h b/src/l2/alice/engine.h
index a7a0b02..c3f6725 100644
--- a/src/l2/alice/engine.h
+++ b/src/l2/alice/engine.h
@@ -824,35 +824,36 @@ struct Alice {
     VkDescriptorSet descriptor_set_for_pipeline_1;
 };
 
-ListNodeAliceGenericMeshHand* Alice_add_generic_mesh(Alice* alice, AliceGenericMeshPath paths){
-    GenericMeshTopology topology;
-    if (SpanU8_is_postfix(cstr(".AliceGenericMesh"), VecU8_to_span(&paths.topology_path) )) {
-        topology = alice_expect_read_generic_mesh_from_file(paths.topology_path);
-    } else if (SpanU8_is_postfix(cstr(".obj"), VecU8_to_span(&paths.topology_path) )) {
-        topology = alice_expect_read_generic_mesh_from_obj_file(paths.topology_path);
-    } else {
-        abortf("Иди своей дорогой\n");
-    }
+ListNodeAliceGenericMeshHand* Alice_add_generic_mesh(Alice* alice, const GenericMeshTopology* topology,
+    AliceGenericMeshTexturePaths t_paths){
+    // GenericMeshTopology topology;
+    // if (SpanU8_is_postfix(cstr(".AliceGenericMesh"), VecU8_to_span(&paths.topology_path) )) {
+    //     topology = alice_expect_read_generic_mesh_from_file(paths.topology_path);
+    // } else if (SpanU8_is_postfix(cstr(".obj"), VecU8_to_span(&paths.topology_path) )) {
+    //     topology = alice_expect_read_generic_mesh_from_obj_file(paths.topology_path);
+    // } else {
+    //     abortf("Иди своей дорогой\n");
+    // }
 
     ListNodeAliceGenericMeshHand* mm_node = safe_calloc(1, sizeof(ListNodeAliceGenericMeshHand));
     AliceGenericMeshHand* mm = &mm_node->el;
-    mm->indexes = topology.indexes.len;
+    mm->indexes = topology->indexes.len;
     mm->instance_attr.count = 0;
     mm->instance_attr.staging = MargaretBufAllocator_alloc(&alice->staging_buffers, 200);
     mm->instance_attr.device_local = MargaretBufAllocator_alloc(&alice->dev_local_buffers, 200);
 
     mm->staging_vbo = MargaretBufAllocator_alloc(&alice->staging_buffers,
-        topology.vertices.len * sizeof(GenericMeshVertex));
+        topology->vertices.len * sizeof(GenericMeshVertex));
     mm->staging_ebo = MargaretBufAllocator_alloc(&alice->staging_buffers,
-        topology.indexes.len * sizeof(U32));
+        topology->indexes.len * sizeof(U32));
 
     // todo: change this, I don't like this at all :(
-    mm->pixels_diffuse = TextureDataR8G8B8A8_read_from_png_nofail(VecU8_to_span(&paths.diffuse_texture_path));
-    mm->pixels_normal = TextureDataR8G8B8A8_read_from_png_nofail(VecU8_to_span(&paths.normal_texture_path));
-    mm->pixels_specular = TextureDataR8_read_from_png_nofail(VecU8_to_span(&paths.specular_texture_path));
-    VecU8_drop(paths.diffuse_texture_path);
-    VecU8_drop(paths.normal_texture_path);
-    VecU8_drop(paths.specular_texture_path);
+    mm->pixels_diffuse = TextureDataR8G8B8A8_read_from_png_nofail(VecU8_to_span(&t_paths.diffuse_texture_path));
+    mm->pixels_normal = TextureDataR8G8B8A8_read_from_png_nofail(VecU8_to_span(&t_paths.normal_texture_path));
+    mm->pixels_specular = TextureDataR8_read_from_png_nofail(VecU8_to_span(&t_paths.specular_texture_path));
+    VecU8_drop(t_paths.diffuse_texture_path);
+    VecU8_drop(t_paths.normal_texture_path);
+    VecU8_drop(t_paths.specular_texture_path);
 
     mm->staging_diffuse_tex_buf = MargaretBufAllocator_alloc(&alice->staging_buffers,
         mm->pixels_diffuse.pixels.len * sizeof(cvec4));
@@ -862,9 +863,9 @@ ListNodeAliceGenericMeshHand* Alice_add_generic_mesh(Alice* alice, AliceGenericM
         mm->pixels_specular.pixels.len * sizeof(U8));
 
     mm->vbo = MargaretBufAllocator_alloc(&alice->dev_local_buffers,
-        topology.vertices.len * sizeof(GenericMeshVertex));
+        topology->vertices.len * sizeof(GenericMeshVertex));
     mm->ebo = MargaretBufAllocator_alloc(&alice->dev_local_buffers,
-        topology.indexes.len * sizeof(U32));
+        topology->indexes.len * sizeof(U32));
 
     mm->diffuse_texture = MargaretImgAllocator_alloc(&alice->dev_local_images,
         mm->pixels_diffuse.width, mm->pixels_diffuse.height,
@@ -883,20 +884,20 @@ ListNodeAliceGenericMeshHand* Alice_add_generic_mesh(Alice* alice, AliceGenericM
 
     /* We allocated enough memory, but now it's time to actually fill staging buffers */
     /* Filleing staging VBO */
-    assert(mm->staging_vbo.len >= topology.vertices.len * sizeof(GenericMeshVertex));
-    assert(mm->vbo.len >= topology.vertices.len * sizeof(GenericMeshVertex));
+    assert(mm->staging_vbo.len >= topology->vertices.len * sizeof(GenericMeshVertex));
+    assert(mm->vbo.len >= topology->vertices.len * sizeof(GenericMeshVertex));
     GenericMeshVertex* staging_vbo = (GenericMeshVertex*)MargaretSubbuf_get_mapped(&mm->staging_vbo);
-    for (U64 i = 0; i < topology.vertices.len; i++) {
-        staging_vbo[i].base = topology.vertices.buf[i];
+    for (U64 i = 0; i < topology->vertices.len; i++) {
+        staging_vbo[i].base = topology->vertices.buf[i];
     }
-    assert(topology.indexes.len % 3 == 0);
-    for (size_t ti = 0; ti * 3 < topology.indexes.len; ti++) {
-        U32 v0 = topology.indexes.buf[ti * 3 + 0];
-        U32 v1 = topology.indexes.buf[ti * 3 + 1];
-        U32 v2 = topology.indexes.buf[ti * 3 + 2];
-        const GenericMeshVertexInc* A0 = VecGenericMeshVertexInc_at(&topology.vertices, v0);
-        const GenericMeshVertexInc* A1 = VecGenericMeshVertexInc_at(&topology.vertices, v1);
-        const GenericMeshVertexInc* A2 = VecGenericMeshVertexInc_at(&topology.vertices, v2);
+    assert(topology->indexes.len % 3 == 0);
+    for (size_t ti = 0; ti * 3 < topology->indexes.len; ti++) {
+        U32 v0 = topology->indexes.buf[ti * 3 + 0];
+        U32 v1 = topology->indexes.buf[ti * 3 + 1];
+        U32 v2 = topology->indexes.buf[ti * 3 + 2];
+        const GenericMeshVertexInc* A0 = VecGenericMeshVertexInc_at(&topology->vertices, v0);
+        const GenericMeshVertexInc* A1 = VecGenericMeshVertexInc_at(&topology->vertices, v1);
+        const GenericMeshVertexInc* A2 = VecGenericMeshVertexInc_at(&topology->vertices, v2);
         vec3 dp1 = vec3_minus_vec3(A1->pos, A0->pos);
         vec3 dp2 = vec3_minus_vec3(A2->pos, A0->pos);
         float du1 = A1->tex.x - A0->tex.x;
@@ -913,11 +914,11 @@ ListNodeAliceGenericMeshHand* Alice_add_generic_mesh(Alice* alice, AliceGenericM
         staging_vbo[v0].tang_V = staging_vbo[v1].tang_V = staging_vbo[v2].tang_V = tang_U_V.y;
     }
     /* Filling EBO is easy */
-    assert(topology.indexes.len == mm->indexes);
-    size_t ebo_len = topology.indexes.len * sizeof(U32);
+    assert(topology->indexes.len == mm->indexes);
+    size_t ebo_len = topology->indexes.len * sizeof(U32);
     assert(mm->ebo.len >= ebo_len);
     U32* staging_ebo = (U32*)MargaretSubbuf_get_mapped(&mm->staging_ebo);
-    memcpy(staging_ebo, topology.indexes.buf, ebo_len);
+    memcpy(staging_ebo, topology->indexes.buf, ebo_len);
     /* Filling staging textures from memory pixel data */
     /* todo: do it immediately ON THE READ */
     memcpy(MargaretSubbuf_get_mapped(&mm->staging_diffuse_tex_buf), mm->pixels_diffuse.pixels.buf,
@@ -1003,56 +1004,55 @@ ListNodeAliceGenericMeshHand* Alice_add_generic_mesh(Alice* alice, AliceGenericM
     return mm_node;
 }
 
-ListNodeAliceShinyMeshHand* Alice_add_shiny_mesh(Alice* alice, VecU8 path){
-    ShinyMeshTopology topology = alice_expect_read_shiny_mesh_from_file(path);
+ListNodeAliceShinyMeshHand* Alice_add_shiny_mesh(Alice* alice, const ShinyMeshTopology* topology){
 
     ListNodeAliceShinyMeshHand* mm_node = safe_calloc(1, sizeof(ListNodeAliceShinyMeshHand));
     AliceShinyMeshHand* mm = &mm_node->el;
 
-    mm->indexes = topology.indexes.len;
+    mm->indexes = topology->indexes.len;
 
     mm->instance_attr.count = 0;
     mm->instance_attr.staging = MargaretBufAllocator_alloc(&alice->staging_buffers, 128);
     mm->instance_attr.device_local = MargaretBufAllocator_alloc(&alice->dev_local_buffers, 128);
 
     mm->staging_vbo = MargaretBufAllocator_alloc(&alice->staging_buffers,
-        topology.vertices.len * sizeof(ShinyMeshVertex));
+        topology->vertices.len * sizeof(ShinyMeshVertex));
     mm->staging_ebo = MargaretBufAllocator_alloc(&alice->staging_buffers,
-        topology.indexes.len * sizeof(U32));
+        topology->indexes.len * sizeof(U32));
 
     mm->vbo = MargaretBufAllocator_alloc(&alice->dev_local_buffers,
-        topology.vertices.len * sizeof(ShinyMeshVertex));
+        topology->vertices.len * sizeof(ShinyMeshVertex));
     mm->ebo = MargaretBufAllocator_alloc(&alice->dev_local_buffers,
-        topology.indexes.len * sizeof(U32));
+        topology->indexes.len * sizeof(U32));
 
     ListAliceShinyMeshHand_insert_node(&alice->shiny_models.hands, mm_node);
     VecRefListNodeAliceShinyMeshHand_append(&alice->shiny_models.to_be_copied_to_device_next_cycle, mm_node);
     /* We allocated enough memory, now it's time to actually fill staging buffers */
     /* And we start by filling staging VBO */
-    assert(mm->staging_vbo.len >= topology.vertices.len * sizeof(ShinyMeshVertex));
-    assert(mm->vbo.len >= topology.vertices.len * sizeof(ShinyMeshVertex));
+    assert(mm->staging_vbo.len >= topology->vertices.len * sizeof(ShinyMeshVertex));
+    assert(mm->vbo.len >= topology->vertices.len * sizeof(ShinyMeshVertex));
     ShinyMeshVertex* staging_vbo = (ShinyMeshVertex*)MargaretSubbuf_get_mapped(&mm->staging_vbo);
-    for (U64 i = 0; i < topology.vertices.len; i++) {
-        staging_vbo[i].base = topology.vertices.buf[i];
+    for (U64 i = 0; i < topology->vertices.len; i++) {
+        staging_vbo[i].base = topology->vertices.buf[i];
     }
-    assert(topology.indexes.len % 3 == 0);
-    for (size_t ti = 0; ti * 3 < topology.indexes.len; ti++) {
-        U32 v0 = topology.indexes.buf[ti * 3 + 0];
-        U32 v1 = topology.indexes.buf[ti * 3 + 1];
-        U32 v2 = topology.indexes.buf[ti * 3 + 2];
-        vec3 p0 = VecShinyMeshVertexInc_at(&topology.vertices, v0)->pos;
-        vec3 p1 = VecShinyMeshVertexInc_at(&topology.vertices, v1)->pos;
-        vec3 p2 = VecShinyMeshVertexInc_at(&topology.vertices, v2)->pos;
+    assert(topology->indexes.len % 3 == 0);
+    for (size_t ti = 0; ti * 3 < topology->indexes.len; ti++) {
+        U32 v0 = topology->indexes.buf[ti * 3 + 0];
+        U32 v1 = topology->indexes.buf[ti * 3 + 1];
+        U32 v2 = topology->indexes.buf[ti * 3 + 2];
+        vec3 p0 = VecShinyMeshVertexInc_at(&topology->vertices, v0)->pos;
+        vec3 p1 = VecShinyMeshVertexInc_at(&topology->vertices, v1)->pos;
+        vec3 p2 = VecShinyMeshVertexInc_at(&topology->vertices, v2)->pos;
         vec3 norm = vec3_normalize(vec3_cross(vec3_minus_vec3(p1, p0), vec3_minus_vec3(p2, p0)));
         staging_vbo[v0].normal = staging_vbo[v1].normal = staging_vbo[v2].normal = norm;
     }
     /* Filling staging EBO is super-duper easy */
 
-    assert(topology.indexes.len == mm->indexes);
-    size_t ebo_len = topology.indexes.len * sizeof(U32);
+    assert(topology->indexes.len == mm->indexes);
+    size_t ebo_len = topology->indexes.len * sizeof(U32);
     assert(mm->ebo.len >= ebo_len);
     U32* staging_ebo = (U32*)MargaretSubbuf_get_mapped(&mm->staging_ebo);
-    memcpy(staging_ebo, topology.indexes.buf, ebo_len);
+    memcpy(staging_ebo, topology->indexes.buf, ebo_len);
     return mm_node;
 }
 
diff --git a/src/l2/lucy/glyph_render.h b/src/l2/lucy/glyph_render.h
index 1a21595..c6493ed 100644
--- a/src/l2/lucy/glyph_render.h
+++ b/src/l2/lucy/glyph_render.h
@@ -164,8 +164,6 @@ void LucyRenderer_another_frame(LucyRenderer* self){
         MargaretBufAllocator_expand_or_free_old(self->ve.dev_local_buffers, &self->vbo, needed_vbo_length);
     }
     if ((self->need_to_transfer) && self->glyphs_count > 0) {
-        printf("LucyRenderer: we are doing copying\n");
-
         self->need_to_transfer = false;
         margaret_rec_cmd_copy_buffer_one_to_one_part(self->ve.transfer_cmd_buffer,
             &self->staging_vbo, &self->vbo, 0, needed_vbo_length);
diff --git a/src/l3/r4/r4.c b/src/l3/r4/r4.c
index 190e042..d7666c4 100644
--- a/src/l3/r4/r4.c
+++ b/src/l3/r4/r4.c
@@ -1,24 +1,44 @@
 #include "../../l2/core/glb_file.h"
 #include "../../l2/alice/engine.h"
+#include "../../l1_5/core/quaternion.h"
+#include "../../l1_5/marie/prim_shape_geom.h"
+#include "../../../gen/l1/VecAndSpan_vec3.h"
+#include "../../l1_5/core/color.h"
+
+typedef struct{
+    vec3 pos;
+    vec3 color;
+    float magnitude;
+} LightSourceState;
+
+#include "../../../gen/l1/eve/r4/VecLightSourceState.h"
 
 typedef struct {
     float mass;
+    /* Center of mass relative to "center of mesh" */
+    vec3 mass_center;
 } RigidBodyConfig;
 
 typedef struct {
+    RigidBodyConfig p;
     vec3 pos;
     vec3 speed;
-    vec3 rot;
-    vec3 rot_speed;
+    quaternion_t rot;
+    quaternion_t rot_speed;
 } RigidBodyState;
 
-AliceGenericMeshPath AliceGenericMeshPath_for_log(SpanU8 root_dir, U64 w, U64 r, U64 k) {
-    return (AliceGenericMeshPath){
-        .topology_path = VecU8_fmt("%s/gen/l2/models/log_%u_%u_%u.AliceGenericMesh", root_dir, w, r, k),
-        .diffuse_texture_path = VecU8_fmt("%s/src/l3/textures/log_%u_%u_%u_diffuse.png", root_dir, w, r, k),
-        .normal_texture_path = VecU8_fmt("%s/gen/l2/textures/log_%u_%u_%u_NORMAL.png", root_dir, w, r, k),
-        .specular_texture_path = VecU8_fmt("%s/src/l3/textures/log_%u_%u_%u_specular.png", root_dir, w, r, k),
-    };
+/* point `M` is relative to the center of mass */
+vec3 RigidBodyState_translate_point(const RigidBodyState* self, vec3 M){
+    return vec3_add_vec3(self->pos, M);
+}
+
+vec3 RigidBodyState_translate_point_of_mesh(const RigidBodyState* self, vec3 M){
+    return RigidBodyState_translate_point(self, vec3_minus_vec3(M, self->p.mass_center));
+}
+
+/* Transforms points relative to center of mass. To get model_t for mesh, multiply transition matrix by this matrix */
+mat4 RigidBodyState_get_tran_mat(const RigidBodyState* self){
+    return marie_translation_mat4(self->pos);
 }
 
 vec3 project_dir_onto_plane_xz(vec3 v){
@@ -31,13 +51,62 @@ typedef struct{
     LucyFace* font_face;
     RBTreeNodeLucyFaceFixedSize* font_face_of_size_40;
     vec3 hero_pos;
-} R4AlphaStuff;
+
+    ListNodeAliceGenericMeshHand* ROA_mesh;
+    GenericMeshTopology ROA_topology;
+    RigidBodyState ROA_state;
+
+    ListNodeAliceShinyMeshHand* LS_mesh;
+    VecLightSourceState LS_state;
+
+    U64 misses_count;
+    U64 hits_count;
+    Vecvec3 bullets_stuck_on_ROA;
+} R4BetaState;
+
+/* We are surrounded by a giant cubic mesh of light sources */
+const int lighting_system_dim = 4;
 
 void main_h_on_wayland_keyboard_key(void* data, U32 keysym, U32 act){
+    R4BetaState *st = data;
+    Alice* alice = st->alice;
+    if (act == WL_KEYBOARD_KEY_STATE_RELEASED && keysym == XKB_KEY_Return) {
+        printf("Shot a bullet!\n");
+        vec3 P = alice->cam_info.cam.pos;
+        vec3 dir = vec3_minus(alice->cam_info.cam.cam_basis.z);
+        vec3 Q = vec3_add_vec3(P, dir);
+        bool hit = false;
+        vec3 impact;
+        VecU32* Is = &st->ROA_topology.indexes;
+        VecGenericMeshVertexInc* Vs = &st->ROA_topology.vertices;
+        assert(Is->len % 3 == 0);
+        // todo: when I make model-t more complex (add rotation), this code will need to be updated
+        for (size_t i = 0; i < Is->len; i += 3) {
+            vec3 A = Vs->buf[Is->buf[i + 0]].pos;
+            vec3 B = Vs->buf[Is->buf[i + 1]].pos;
+            vec3 C = Vs->buf[Is->buf[i + 2]].pos;
+            A = RigidBodyState_translate_point_of_mesh(&st->ROA_state, A);
+            B = RigidBodyState_translate_point_of_mesh(&st->ROA_state, B);
+            C = RigidBodyState_translate_point_of_mesh(&st->ROA_state, C);
+            hit = marie_intersect_triangle_and_ray(A, B, C, P, Q, &impact);
+            if (hit)
+                break;
+        }
+        if (hit) {
+            st->hits_count++;
+            /* See, for some dumb reason I decided that bullets share a mesh with light sources. They are all cubes */
+            // U64 n = st->bullets_stuck_on_ROA.len + st->LS_state.len;
+            assert(st->bullets_stuck_on_ROA.len + st->LS_state.len == st->LS_mesh->el.instance_attr.count);
+            vec3 impact_from_center = vec3_minus_vec3(impact, st->ROA_state.pos);
+            Vecvec3_append(&st->bullets_stuck_on_ROA, impact_from_center);
+        } else {
+            st->misses_count++;
+        }
+    }
 }
 
 void main_h_on_another_frame(void* data, float fl){
-    R4AlphaStuff *st = data;
+    R4BetaState *st = data;
     Alice* alice = st->alice;
     vec3 proj_back = project_dir_onto_plane_xz(alice->cam_info.cam.cam_basis.z);
     vec3 proj_right = project_dir_onto_plane_xz(alice->cam_info.cam.cam_basis.x);
@@ -62,16 +131,56 @@ void main_h_on_another_frame(void* data, float fl){
     }
     alice->cam_info.cam.pos = st->hero_pos;
 
-    // margaret_ns_time TIME = margaret_clock_gettime_monotonic_raw();
-    // printf("Updating text\n");
-    // LucyRenderer_clear(&alice->lucy_renderer);
-    // VecU8 text = VecU8_fmt("Time is %u.%u\nHave a good day sir\n", (U64)TIME.tv_sec, (U64)TIME.tv_nsec);
-    // LucyRenderer_add_text(&alice->lucy_renderer, st->font_face_of_size_40, (vec4){0.1f, 0.2f, 0, 1}, 0,
-    //     VecU8_to_span(&text), (ivec2){100, 100});
+    AliceGenericMeshHand_set_inst(&st->ROA_mesh->el, 0, (GenericMeshInstanceInc){
+        .model_t = mat4_mul_mat4(RigidBodyState_get_tran_mat(&st->ROA_state),
+            marie_translation_mat4(vec3_minus(st->ROA_state.p.mass_center))),
+    });
+
+    Pipeline0UBO* ubo = (Pipeline0UBO*)MargaretSubbuf_get_mapped(&st->alice->pipeline0_ubo.staging);
+    assert(pipeline_0_ubo_point_light_max_count >= st->LS_state.len);
+
+    for (size_t i = 0; i < st->LS_state.len; i++) {
+        LightSourceState* ls = &st->LS_state.buf[i];
+        AliceShinyMeshHand_set_inst(&st->LS_mesh->el, i, (ShinyMeshInstanceInc){
+            .color_on = ls->color,
+            .model_t = marie_translation_mat4(ls->pos),
+        });
+        ubo->point_light_arr[i] = (Pipeline0PointLight){
+            .pos = ls->pos, .color =  vec3_mul_scal(ls->color, 21)};
+    }
+    if (st->LS_state.len + st->bullets_stuck_on_ROA.len > st->LS_mesh->el.instance_attr.count) {
+        AliceShinyMeshHand_resize_instance_arr(alice, &st->LS_mesh->el, st->LS_state.len + st->bullets_stuck_on_ROA.len);
+    }
+
+    for (size_t i = 0; i < st->bullets_stuck_on_ROA.len; i++) {
+        vec3 bul_pos = st->bullets_stuck_on_ROA.buf[i];
+        AliceShinyMeshHand_set_inst(&st->LS_mesh->el, st->LS_state.len + i, (ShinyMeshInstanceInc){
+            .color_on = (vec3){2, 0, 0},
+            .model_t = mat4_mul_mat4(mat4_mul_mat4(
+            RigidBodyState_get_tran_mat(&st->ROA_state),
+            marie_translation_mat4(bul_pos)),
+            marie_3d_scal_mat4(0.069f)),
+        });
+    }
+
+    LucyRenderer_clear(&alice->lucy_renderer);
+    VecU8 text = VecU8_new();
+    if (st->misses_count == 0 && st->hits_count == 0) {
+        VecU8_append_cstr(&text, "Press ENTER to shoot\n");
+    }
+    if (st->misses_count > 0) {
+        VecU8_append_fmt(&text, "You missed %u times\n", st->misses_count);
+    }
+    if (st->hits_count > 0) {
+        VecU8_append_fmt(&text, "You hit ROA %u times\n", st->hits_count);
+    }
+    LucyRenderer_add_simple_label(&alice->lucy_renderer, st->font_face_of_size_40, (vec4){0, 0, 0, 1}, 0,
+        VecU8_to_span(&text), (ivec2){10, 10});
+    VecU8_drop(text);
 }
 
 void run_app(){
-    R4AlphaStuff st;
+    R4BetaState st;
     st.hero_pos = (vec3){0, 0.81f, 0};
     Alice* alice = Alice_new();
     st.alice = alice;
@@ -98,83 +207,68 @@ void run_app(){
 
     LucyGlyphCache_add_glyphs(lucy_requests);
     LucyRenderer_add_simple_label(&st.alice->lucy_renderer, st.font_face_of_size_40, (vec4){0, 0, 0, 1}, 0,
-        cstr("Bebra budet\nотнюхана\n"), (ivec2){10, 10});
+        cstr("..."), (ivec2){10, 10});
 
-    ListNodeAliceGenericMeshHand* model_gen = Alice_add_generic_mesh(st.alice, AliceGenericMeshPath_for_log(cstr("."), 10, 2, 6));
-    AliceGenericMeshHand_resize_instance_arr(st.alice, &model_gen->el, 1);
+    VecU8 ROA_mesh_path = vcstr("./gen/l2/models/log_10_2_6.AliceGenericMesh");
+    st.ROA_topology = alice_expect_read_generic_mesh_from_file(ROA_mesh_path);
 
-    for (int X = 0; X < 1; X++) {
-        for (int Z = 0; Z < 1; Z++) {
-            AliceGenericMeshHand_set_inst(&model_gen->el, X * 10 + Z, (GenericMeshInstanceInc){
-                .model_t = marie_translation_mat4((vec3){11.f * (float)X, -6, 4.f * (float)Z}),
-            });
-        }
-    }
-
-    ListNodeAliceShinyMeshHand *model_sh = Alice_add_shiny_mesh(st.alice, vcstr("./gen/l2/models/cube.AliceShinyMesh"));
-    AliceShinyMeshHand_resize_instance_arr(st.alice, &model_sh->el, 100);
-
-    for (int X = 0; X < 10; X++) {
-        for (int Z = 0; Z < 10; Z++) {
-            AliceShinyMeshHand_set_inst(&model_sh->el, X * 10 + Z, (ShinyMeshInstanceInc){
-                .color_on = {0, 1, 0},
-                .model_t = marie_translation_mat4((vec3){11.f * (float)X - 20, 10, 4.f * (float)Z - 10}),
-            });
+    st.ROA_mesh = Alice_add_generic_mesh(st.alice, &st.ROA_topology,
+        (AliceGenericMeshTexturePaths){
+            .diffuse_texture_path = vcstr("./src/l3/textures/log_10_2_6_diffuse.png"),
+            .normal_texture_path = vcstr("./gen/l2/textures/log_10_2_6_NORMAL.png"),
+            .specular_texture_path = vcstr("./src/l3/textures/log_10_2_6_specular.png")
+        });
+    AliceGenericMeshHand_resize_instance_arr(st.alice, &st.ROA_mesh->el, 1);
+    st.ROA_state = (RigidBodyState){
+        .p.mass = 100.f, .p.mass_center = (vec3){5, 0.77f, -0.77f},
+        .pos = (vec3){11.f, 3, 4}, .speed = {0},
+        .rot = (vec4){1, 0, 0, 0}, .rot_speed = (vec4){1, 0, 0, 0}};
+
+
+    ShinyMeshTopology LS_topology = alice_expect_read_shiny_mesh_from_file(vcstr("./gen/l2/models/cube.AliceShinyMesh"));
+    st.LS_mesh = Alice_add_shiny_mesh(st.alice, &LS_topology);
+    ShinyMeshTopology_drop(LS_topology);
+
+    const int cubes_in_light_wall = lighting_system_dim * lighting_system_dim;
+    st.LS_state = VecLightSourceState_new_reserved(cubes_in_light_wall * 6);
+    const vec3 light_cage_ways[6][2] = {
+        {{0, 1, 0}, {0, 0, 1}}, {{0, 0, 1}, {0, 1, 0}},
+        {{1, 0, 0}, {0, 0, 1}}, {{0, 0, 1}, {1, 0, 0}},
+        {{1, 0, 0}, {0, 1, 0}}, {{0, 1, 0}, {1, 0, 0}},
+    };
+    const float light_case_edge_offset = 6.1f;
+    const float light_case_gap = 12.5f;
+    const float light_cage_rad = (float)(lighting_system_dim - 1) * light_case_gap / 2 + light_case_edge_offset;
+
+    for (U64 s = 0; s < 6; s++) {
+        vec3 u = light_cage_ways[s][0];
+        vec3 v = light_cage_ways[s][1];
+        vec3 dir = vec3_mul_scal(vec3_cross(u, v), light_cage_rad);
+
+        for (U64 i = 0; i < lighting_system_dim; i++) {
+            for (U64 j = 0; j < lighting_system_dim; j++) {
+                vec3 clr = sample_rainbow_color();
+                VecLightSourceState_append(&st.LS_state, (LightSourceState){
+                    .pos = vec3_add_vec3(dir, vec3_add_vec3(
+                        vec3_mul_scal(u, -light_cage_rad + light_case_edge_offset + light_case_gap * (float)i),
+                        vec3_mul_scal(v, -light_cage_rad + light_case_edge_offset + light_case_gap * (float)j))),
+                    .color = clr,
+                    .magnitude = 1
+                });
+            }
         }
     }
 
+    AliceShinyMeshHand_resize_instance_arr(st.alice, &st.LS_mesh->el, st.LS_state.len);
     Pipeline0UBO* ubo = (Pipeline0UBO*)MargaretSubbuf_get_mapped(&st.alice->pipeline0_ubo.staging);
-    assert(pipeline_0_ubo_point_light_max_count >= 100);
-    ubo->point_light_count = 100;
+    assert(pipeline_0_ubo_point_light_max_count >= st.LS_state.len);
+    ubo->point_light_count = (int)st.LS_state.len;
     ubo->spotlight_count = 0;
-    for (int X = 0; X < 10; X++) {
-        for (int Z = 0; Z < 10; Z++) {
-            ubo->point_light_arr[X * 10 + Z] = (Pipeline0PointLight){
-                .pos = (vec3){11.f * (float)X - 20, 10, 4.f * (float)Z - 10},
-                .color = {5, 5, 5}
-            };
-        }
-    }
-    ubo->point_light_arr[0].color = (vec3){100, 100, 100};
 
+    st.misses_count = 0;
+    st.hits_count = 0;
+    st.bullets_stuck_on_ROA = Vecvec3_new();
 
-    ListNodeAliceGenericMeshHand* skeleton_mesh = Alice_add_generic_mesh(st.alice, (AliceGenericMeshPath){
-        .topology_path = vcstr("./src/l3/models/skeleton.obj"),
-        .diffuse_texture_path = vcstr("./src/l3/models/bone.png"),
-        .normal_texture_path = vcstr("./gen/l2/textures/flat_NORMAL.png"),
-        .specular_texture_path = vcstr("./gen/l2/textures/flat_NORMAL.png"),
-    });
-
-    AliceGenericMeshHand_resize_instance_arr(alice, &skeleton_mesh->el, 1);
-    AliceGenericMeshHand_set_inst(&skeleton_mesh->el, 0, (GenericMeshInstanceInc){
-        .model_t = marie_translation_mat4((vec3){5.f, -3, 12.f}),
-    });
-
-    ListNodeAliceGenericMeshHand* floor1_mesh = Alice_add_generic_mesh(st.alice, (AliceGenericMeshPath){
-        .topology_path = vcstr("gen/l2/models/floor1.AliceGenericMesh"),
-        .diffuse_texture_path = vcstr("src/l3/textures/wood.png"),
-        .normal_texture_path = vcstr("gen/l2/textures/flat_NORMAL.png"),
-        .specular_texture_path = vcstr("gen/l2/textures/no_SPECULAR.png"),
-    });
-    AliceGenericMeshHand_resize_instance_arr(alice, &floor1_mesh->el, 1);
-    AliceGenericMeshHand_set_inst(&floor1_mesh->el, 0, (GenericMeshInstanceInc){
-        .model_t = marie_translation_mat4((vec3){0, 0, 0}),
-    });
-
-    ListNodeAliceGenericMeshHand* model_puck = Alice_add_generic_mesh(st.alice, (AliceGenericMeshPath){
-        .topology_path = vcstr("gen/l2/models/puck.AliceGenericMesh"),
-        .diffuse_texture_path = vcstr("src/l3/textures/puck_diffuse.png"),
-        .normal_texture_path = vcstr("gen/l2/textures/puck_NORMAL.png"),
-        .specular_texture_path = vcstr("src/l3/textures/puck_specular.png"),
-    });
-    AliceGenericMeshHand_resize_instance_arr(st.alice, &model_puck->el, 100);
-    for (int X = 0; X < 10; X++) {
-        for (int Z = 0; Z < 10; Z++) {
-            AliceGenericMeshHand_set_inst(&model_puck->el, X * 10 + Z, (GenericMeshInstanceInc){
-                .model_t = marie_translation_mat4((vec3){11.f * (float)X - 20, -1, 4.f * (float)Z - 10}),
-            });
-        }
-    }
     Alice_mainloop(st.alice, &(AliceCallbacks){
         .on_wl_keyboard_key = main_h_on_wayland_keyboard_key,
         .on_another_frame = main_h_on_another_frame,
@@ -183,14 +277,4 @@ void run_app(){
 
 int main(){
     run_app();
-    VecU8 file = read_file_by_path(vcstr("./src/l3/models/skeleton.glb"));
-    GLBFileSegments data;
-    int c = glb_file_get_segments(VecU8_to_span(&file), &data);
-    if (c > 0) {
-        abortf("Incorrect glb ==> %d\n", c);
-    }
-    VecU8 json_text = json_encode(&data.gltf);
-    VecU8_print(json_text);
-    GLBFileSegments_drop(data);
-    VecU8_drop(file);
 }
diff --git a/src/l_adele/alice/0sh/0sh.frag b/src/l_adele/alice/0sh/0sh.frag
index 8e9e77c..8a10360 100644
--- a/src/l_adele/alice/0sh/0sh.frag
+++ b/src/l_adele/alice/0sh/0sh.frag
@@ -1,7 +1,7 @@
 #version 450
 
 layout(location = 0) in vec3 norm;
-                                                      layout(location = 1) in vec3 color_off;
+layout(location = 1) in vec3 color_off;
 layout(location = 2) in vec3 color_on;
 layout(location = 3) in vec3 pos;