My game calendar menu now with snow AND with “realistic” snow growth. It’s very relaxing to watch the snow falling and growing. =)
A gif a gif a gif a gif a gif a gif a gif :
Working on the tutorial series I started, next part is a custom menu:
code https://github.com/tyler6699/evoscape/tree/tutorial_011
I made a lot of progress with a platformer I’ve been working on. This is my first time implementing a platforming system that isn’t both tile based and axis aligned, and I think it’s working out very nicely. It’s also the first time I’ve tried implementing moving platforms, and I think I’ll be able to get it to handle rotating platforms as well.
Looks good thus far!
Long time no see guys. How is everyone?
We decided to scrap the world generator for a world editor that the players can use too. This is speeding up development by a large margin and will hopefully set Robot Farm apart from other RPGs more. This thing only took like a week to make and can already produce more interesting results than the generator we hacked at for multiple months:
Procgen is far harder than it looks to make interesting constructs. Hand-crafted is far more time consuming than anyone realises. Having users generate content is almost the best solution except they will also inevitably fill your world with pictures of drippy cocks.
Cas
There’s good to be found even in drippy penises being made with your editor, it means someone is using the editor lol
It’s actually interesting, the editor still uses some of the generators systems. The world’s foundation is made with the generator, then a human will overlay details that are more easily made with hands. So you don’t have full control, but enough to change the experience of gameplay.
I finally completed the last bits of the first pass of my BASIC V2 to native 6502 machine language compiler (written in Java, of course). It takes a program written in Commodore BASIC V2 (https://en.wikipedia.org/wiki/Commodore_BASIC) and compiles it into an intermediate assembly language that is somehow a bastard child of x86 and 6502 and then something.
For example, this (part of a) BASIC program (an affine texture mapper that I wrote some months ago):
....
610 gosub 2400
620 tc%=0
630 for i=0 to 17 step 9
640 t%=0:l%=3:r%=6
650 tt%=0:tl%=2:tr%=4
660 if xy%(i+4)>=xy%(i+1) then 690
670 t%=3:l%=6:r%=0
680 tt%=2:tl%=4:tr%=0
690 rem jump target
700 if xy%(i+7)>=xy%(i+t%+1) then 730
710 t%=6:l%=0:r%=3
720 tt%=4:tl%=0:tr%=2
730 rem jump target
740 t%=t%+i
750 l%=l%+i
760 r%=r%+i
770 tt%=tt%+tc%
780 tl%=tl%+tc%
790 tr%=tr%+tc%
800 dl%=(xy%(l%)-xy%(t%))*di%
810 dr%=(xy%(r%)-xy%(t%))*di%
820 u0%=(ts%(tl%)-ts%(tt%))*di%
830 u1%=(ts%(tr%)-ts%(tt%))*di%
840 v0%=(ts%(tl%+1)-ts%(tt%+1))*di%
850 v1%=(ts%(tr%+1)-ts%(tt%+1))*di%
860 n%=l%
870 if xy%(n%+1)<=xy%(r%+1) then 890
...
gets compiled into this (also partially shown):
...
610:
JSR GOSUB
JSR 2400
620:
MOV Y,#0{INTEGER}
MOV TC%{INTEGER},Y
630:
MOV Y,#17{INTEGER}
PUSH Y
MOV Y,#9{INTEGER}
PUSH Y
MOV Y,#0{INTEGER}
MOV I{REAL},Y
MOV A,(I{REAL})
JSR INITFOR
640:
MOV Y,#0{INTEGER}
MOV T%{INTEGER},Y
MOV Y,#3{INTEGER}
MOV L%{INTEGER},Y
MOV Y,#6{INTEGER}
MOV R%{INTEGER},Y
650:
MOV Y,#0{INTEGER}
MOV TT%{INTEGER},Y
MOV Y,#2{INTEGER}
MOV TL%{INTEGER},Y
MOV Y,#4{INTEGER}
MOV TR%{INTEGER},Y
660:
MOV Y,#1{INTEGER}
MOV X,I{REAL}
ADD X,Y
MOV G,XY%[]{INTEGER}
CHGCTX #0
JSR ARRAYACCESS
PUSH X
MOV Y,#4{INTEGER}
MOV X,I{REAL}
ADD X,Y
MOV G,XY%[]{INTEGER}
CHGCTX #0
JSR ARRAYACCESS
POP Y
GTEQ X,Y
CMP X,#0{REAL}
JNE NSKIP19
JMP SKIP19
NSKIP19:
JMP 690
SKIP19:
670:
MOV Y,#3{INTEGER}
MOV T%{INTEGER},Y
MOV Y,#6{INTEGER}
MOV L%{INTEGER},Y
MOV Y,#0{INTEGER}
MOV R%{INTEGER},Y
680:
MOV Y,#2{INTEGER}
MOV TT%{INTEGER},Y
MOV Y,#4{INTEGER}
MOV TL%{INTEGER},Y
MOV Y,#0{INTEGER}
MOV TR%{INTEGER},Y
690:
NOP
700:
MOV Y,T%{INTEGER}
MOV X,I{REAL}
ADD X,Y
MOV Y,#1{INTEGER}
ADD X,Y
MOV G,XY%[]{INTEGER}
CHGCTX #0
JSR ARRAYACCESS
PUSH X
MOV Y,#7{INTEGER}
MOV X,I{REAL}
ADD X,Y
MOV G,XY%[]{INTEGER}
CHGCTX #0
JSR ARRAYACCESS
POP Y
GTEQ X,Y
CMP X,#0{REAL}
JNE NSKIP20
JMP SKIP20
NSKIP20:
JMP 730
SKIP20:
710:
MOV Y,#6{INTEGER}
MOV T%{INTEGER},Y
MOV Y,#0{INTEGER}
MOV L%{INTEGER},Y
MOV Y,#3{INTEGER}
MOV R%{INTEGER},Y
720:
MOV Y,#4{INTEGER}
MOV TT%{INTEGER},Y
MOV Y,#0{INTEGER}
MOV TL%{INTEGER},Y
MOV Y,#2{INTEGER}
MOV TR%{INTEGER},Y
730:
NOP
740:
MOV Y,I{REAL}
MOV X,T%{INTEGER}
ADD X,Y
MOV T%{INTEGER},X
750:
MOV Y,I{REAL}
MOV X,L%{INTEGER}
ADD X,Y
MOV L%{INTEGER},X
760:
MOV Y,I{REAL}
MOV X,R%{INTEGER}
ADD X,Y
MOV R%{INTEGER},X
770:
MOV Y,TC%{INTEGER}
MOV X,TT%{INTEGER}
ADD X,Y
MOV TT%{INTEGER},X
780:
MOV Y,TC%{INTEGER}
MOV X,TL%{INTEGER}
ADD X,Y
MOV TL%{INTEGER},X
790:
MOV Y,TC%{INTEGER}
MOV X,TR%{INTEGER}
ADD X,Y
MOV TR%{INTEGER},X
800:
MOV X,T%{INTEGER}
MOV G,XY%[]{INTEGER}
CHGCTX #0
JSR ARRAYACCESS
PUSH X
MOV X,L%{INTEGER}
MOV G,XY%[]{INTEGER}
CHGCTX #0
JSR ARRAYACCESS
POP Y
SUB X,Y
MOV Y,DI%{INTEGER}
MUL X,Y
MOV DL%{INTEGER},X
810:
MOV X,T%{INTEGER}
MOV G,XY%[]{INTEGER}
CHGCTX #0
JSR ARRAYACCESS
PUSH X
MOV X,R%{INTEGER}
MOV G,XY%[]{INTEGER}
CHGCTX #0
JSR ARRAYACCESS
POP Y
SUB X,Y
MOV Y,DI%{INTEGER}
MUL X,Y
MOV DR%{INTEGER},X
820:
MOV X,TT%{INTEGER}
MOV G,TS%[]{INTEGER}
CHGCTX #0
JSR ARRAYACCESS
PUSH X
MOV X,TL%{INTEGER}
MOV G,TS%[]{INTEGER}
CHGCTX #0
JSR ARRAYACCESS
POP Y
SUB X,Y
MOV Y,DI%{INTEGER}
MUL X,Y
MOV U0%{INTEGER},X
830:
MOV X,TT%{INTEGER}
MOV G,TS%[]{INTEGER}
CHGCTX #0
JSR ARRAYACCESS
PUSH X
MOV X,TR%{INTEGER}
MOV G,TS%[]{INTEGER}
CHGCTX #0
JSR ARRAYACCESS
POP Y
SUB X,Y
MOV Y,DI%{INTEGER}
MUL X,Y
MOV U1%{INTEGER},X
840:
MOV Y,#1{INTEGER}
MOV X,TT%{INTEGER}
ADD X,Y
MOV G,TS%[]{INTEGER}
CHGCTX #0
JSR ARRAYACCESS
PUSH X
MOV Y,#1{INTEGER}
MOV X,TL%{INTEGER}
ADD X,Y
MOV G,TS%[]{INTEGER}
CHGCTX #0
JSR ARRAYACCESS
POP Y
SUB X,Y
MOV Y,DI%{INTEGER}
MUL X,Y
MOV V0%{INTEGER},X
850:
MOV Y,#1{INTEGER}
MOV X,TT%{INTEGER}
ADD X,Y
MOV G,TS%[]{INTEGER}
CHGCTX #0
JSR ARRAYACCESS
PUSH X
MOV Y,#1{INTEGER}
MOV X,TR%{INTEGER}
ADD X,Y
MOV G,TS%[]{INTEGER}
CHGCTX #0
JSR ARRAYACCESS
POP Y
SUB X,Y
MOV Y,DI%{INTEGER}
MUL X,Y
MOV V1%{INTEGER},X
860:
MOV Y,L%{INTEGER}
MOV N%{INTEGER},Y
870:
MOV Y,#1{INTEGER}
MOV X,R%{INTEGER}
ADD X,Y
MOV G,XY%[]{INTEGER}
CHGCTX #0
JSR ARRAYACCESS
PUSH X
MOV Y,#1{INTEGER}
MOV X,N%{INTEGER}
ADD X,Y
MOV G,XY%[]{INTEGER}
CHGCTX #0
JSR ARRAYACCESS
POP Y
LTEQ X,Y
CMP X,#0{REAL}
JNE NSKIP21
JMP SKIP21
NSKIP21:
JMP 890
SKIP21:
...
…which then will be executed by a simple interpreter for that strange pseudo assembly code that I wrote.
Which then results into this:
The next step is to convert this into actual 6502 assembly code and then assemble that (the assembler for that is already done as well) into actual machine code.
New weapon textures:
New view management system:
Basically, you will be able to have as many cameras as you want, wherever you want. They will be able to have waypoints you can teleport back to for even more uninterrupted building. They are all functional, and as you can see, there is an inventory GUI that can be moved around too. That window functionality took another (I think my 4th) rewrite of the GUI system, but it wasn’t a total one, thankfully.
I’m currently working on adding a dimension adjuster for the windows so you can resize them.
Submitted my first grant application for a research project! I’ve been planning to release 2 papers a year until my I start my PhD and so far I’m right on track - first semester is almost over and I’ve got one paper being published soon and another one in the works with this grant. I’ll be presenting my first one at a local SIAM conference soon so when that comes up I’ll try to get a recording or something maybe. Super excited, I’m loving college.
Edit: some of the things I’ve worked on over the past week.
GbQQJXAcgo4
topics?
The second is a study on reinforcement/adaptive learning in humans and machines. I’m taking a look at improving current RL models. The first was on a algorithm I found to quickly and easily bruteforce a portion of trigonometric integration on a computer. I know bruteforce and quick doesn’t usually go together but I derived a neat formula that allows me to do just that. Not huge leaps and bounds in the fields but it’s ok for my first published papers. I may post a link to them after they’re published if anyone’s interested.
Pixel dailies theme was Cactus, made this:
Looks great ^
Do let us know when you have something playable!
Finished tutorial 11, this one goes through creating a basic menu with some buttons.
I will look at saving & loading next, not sure if this “game” will ever be completed but will hopefully encourage someone to make their own game and help start them off on the right track (Or at least a track of sorts).
Yesterday and today I’ve begun writing the first “code-centric” tutorials on implementing an unbiased importance-sampled path tracer in LWJGL 3 with OpenGL compute shaders. The idea of this kind of tutorial is to read Java and GLSL code from top to bottom and have JavaDocs and comments explaining things as you go. The important thing is that you are always in working source code.
I wanted to pick up on the LWJGL3 GitHub Wiki entry I’ve written in 2014 and write one working version from start right up to implementing filtering algorithms (such as the 2010 Edge-Avoiding À-Trous Filter paper or Nvidia’s 2017 spatiotemporal enhancement of it) to make it suitable for real-time rendering.
Tutorial 1 introduces the LWJGL3 and compute shader setup for very simple primary ray raytracing to intersect with geometry
Tutorial 2 adds unbiased Monte Carlo integration of lambertian/diffuse BRDFs
Tutorial 3 adds unbiased importance sampling of diffuse and specular BRDF components to highlight the “importance” of importance sampling for BRDFs which have strong features in certain directions, such as Phong
Tutorial 4 will add “multiple importance” sampling for efficiently sampling (small) light sources
Tutorial 3 with importance sampling:
Tutorial 3 with uniform hemisphere sampling:
Java sources: https://github.com/LWJGL/lwjgl3-demos/tree/master/src/org/lwjgl/demo/opengl/raytracing/tutorial
EDIT: Added Tutorial 4 with Multiple Importance sampling using Eric Veach’s “balance heuristic” weighting and the one-sample model (i.e. randomly sampling either the light or the hemisphere).
Tutorial 4 without MI:
and with MI:
Note that this is a completely unbiased solution, so both images will converge to the exact same result (given enough time for the first one of course).
Added Tutorial 4 today (see above edit).
Veeeeeeeery nice
Working WebKit based web browser in LWJGL 3:
It still requires lots of work, but is very convenient to use (using JavaFX built-in WebEngine and no external libraries at all). The biggest and pretty much the only problem for now is that texture of rendered page is transferred from CPU to GPU on every frame, some kind of streaming should remove most of that overhead.