ANTONBLAST (2024) (Action Platform) (Nintendo Switch) [GAMEPLAY] [EN] [HD]
YT : https://www.youtube.com/watch?v=xvYvX5FTZpI
#switch #antonblast #nintendoswitch #2024 #action #platform #neoretro #videogame #games #gaming #gameplay #summitsphere
Recent searches
Search options
#neoretro
0 posts0 participants0 posts today
Sam's Journey (2024) (Platform) (NES) [GAMEPLAY] [EN] [HD]
YT : https://www.youtube.com/watch?v=Sz6-E48ZQl0
#neoretro #samsjourney #nes #2024 #platform #videogame #gameplay #polyplay #knightsofbytes #games #gaming
OVER OBJ (2023) (Shoot Em Up) (Famicom/NES) [GAMEPLAY] [EN] [HD]
YT : https://www.youtube.com/watch?v=Mr-bSgdkBGA
#neoretro #overobj #famicom #nes #2023 #shmup #videogame #gameplay #littlesound #neodolphinoproductions #kadenken #games #gaming
Un début de phase de combat (très inspiré des FF IV/V/VI) !
Pas encore de menus, mais je prépare le terrain :
- les combattants ont une variable Ready, et attaquent quand elle tombe à zéro
- les attaques sont des "battle events", un mini script indiquant le message à afficher, l'anim à jouer, l'ajout du compteur de dégats, etc.
- Les anims sont une liste de sprites à la position interpolée linéairement, et affichés pendant une période donnée.
Rien que des des pixels
J'explore TIC-80 en essayant de faire un mini RPG.
- La palette est celle du PICO-8.
- Les murs sont marqués avec les bordures pour les collisions plutôt que l'entièreté. Ça permet des murs fins !
- Le perso contrôlé glisse sur les coins plutôt que de rester coincer contre un mur.
- J'implémente les phases de jeu en assignant la variable `TIC` directement (Par exemple `TIC=TIC_field` ou `TIC=TIC_dialog`).
GIF
@mos_8502 personally, I'd love to see more of those developments because getting #NewOldStock or #KnownWorking #used #RAM can be a real nightmare and having something where one at worst can just chug a #PSRAM chip on, set a #DIP to limit it's size and a connector for the refresh power if needed may be a better option long-term...
Espechally with those super old systems where all the RAM modules are just on a single bus / channel and thus unless it's like #Rambus garbage one doesn't even need to terminate contacts but could in theory just make a system believe it's "fully stacked" with a single SIMM.
It'll also help people like @ActionRetro having to cannibalize machines to max some out...
Also yean, some nice #NeoRetro #8bit machines would benefit from it as well...
So, I worked on this admittedly b0nkers stuff last night. But the good news is that I think I've worked out how it should work out!
Extending the Z80 Architecture: A 24-bit Addressing Mode for the ZX Spectrum
This is a RFC for a work in progress. Sophisticated thoughts and comments are welcome.
It's very retro, and very neo at the same time, pick the kind you like!
https://drive.google.com/file/d/16kNAj5LJX0Qim1Jno5WN7QNjlGazusP0/view?usp=sharing
UPDATE: The original PDF contained errors describing the opcodes for the pseudo-instructions. They have been fixed.
I just figured out how to generate lines on a compute shader. The program generates 100 lines with 1000 vertices in each line, then renders them as line strips.
This is the kind of thing I used to draw when GPUs didn't exist even in sci-fi XD
Next I'll try to render triangle strips and plain triangles.
![fun main() = application {
program {
val vb = vertexBuffer(vertexFormat {
position(3) // 3 floats * 4 = 12 bytes
padding(4) // 4 additional bytes for a multiple of 16 bytes (12+4)
}, 1000)
@Language("GLSL")
val glsl = """
#version 450 core
layout (local_size_x = 64, local_size_y = 1) in;
layout (std430, binding=0) buffer VertexBuffer {
vec3 verts[];
};
uniform vec2 off;
void main(void) {
uint idx = gl_GlobalInvocationID.x;
float t = float(idx) * 0.1 + off.x;
verts[idx].x = sin(t) * cos(t * 0.51 + sin(-t * 0.25 + off.y)) * 300.0 + 320.0;
verts[idx].y = cos(t + sin(t * 0.49 - off.y * 0.25)) * 220.0 + 240.0;
}
"""
val cs2 = ComputeShader.fromCode(glsl, "Comp2")
cs2.buffer("VertexBuffer", vb)
extend {
repeat(100) {
cs2.uniform("off", Vector2(seconds, seconds * 0.33 + it * 0.01))
cs2.execute(1000)
drawer.fill =mixSpectral(ColorRGBa.MEDIUM_VIOLET_RED, ColorRGBa.DARK_KHAKI, it / 99.0).opacify(0.1).toSRGB()
drawer.vertexBuffer(vb, DrawPrimitive.LINE_STRIP)
}
}
}
}](https://files.genart.social/media_attachments/files/111/810/182/685/202/469/original/b0dc762834d10ee8.png "fun main() = application {
program {
val vb = vertexBuffer(vertexFormat {
position(3) // 3 floats * 4 = 12 bytes
padding(4) // 4 additional bytes for a multiple of 16 bytes (12+4)
}, 1000)
@Language(\"GLSL\")
val glsl = \"\"\"
#version 450 core
layout (local_size_x = 64, local_size_y = 1) in;
layout (std430, binding=0) buffer VertexBuffer {
vec3 verts[];
};
uniform vec2 off;
void main(void) {
uint idx = gl_GlobalInvocationID.x;
float t = float(idx) * 0.1 + off.x;
verts[idx].x = sin(t) * cos(t * 0.51 + sin(-t * 0.25 + off.y)) * 300.0 + 320.0;
verts[idx].y = cos(t + sin(t * 0.49 - off.y * 0.25)) * 220.0 + 240.0;
}
\"\"\"
val cs2 = ComputeShader.fromCode(glsl, \"Comp2\")
cs2.buffer(\"VertexBuffer\", vb)
extend {
repeat(100) {
cs2.uniform(\"off\", Vector2(seconds, seconds * 0.33 + it * 0.01))
cs2.execute(1000)
drawer.fill =mixSpectral(ColorRGBa.MEDIUM_VIOLET_RED, ColorRGBa.DARK_KHAKI, it / 99.0).opacify(0.1).toSRGB()
drawer.vertexBuffer(vb, DrawPrimitive.LINE_STRIP)
}
}
}
}")
9bitcolor presents: Atic Atac Remake, for the #ZXSpectrumNext
Reported not to work on emulators currently, but I would expect #ZEsarUX to catch up soon!
Hopefully the release of quality games such as this one will encourage more people to embrace the Next and/or one of the more accessible Next-compatible computers such as the #NGO and the #ZXTRES.
Download:
https://9bitcolor.itch.io/atic-atac-next
Video demo:
https://www.youtube.com/watch?v=SlZnu0dlGVU
Replied in thread
@ajroach42 how will you put in the BASIC interpreter, in (ep)ROM or from an micros card?
Do you plan to write your own interpreter, or will you use something already existing?