Is there any way i can fix this or am i boned?

https://ldjam.com/events/ludum-dare/51/returnal

Play his game here https://ldjam.com/events/ludum-dare/51/sweetheart-speedrun

(Without her realizing you're secretly a shark?)

Play Channel Flipper here: https://ldjam.com/events/ludum-dare/51/channel-flipper

I'm almost there! 10 to go!

Play the game here:

https://ldjam.com/events/ludum-dare/51/paralland

https://ldjam.com/events/ludum-dare/51/the-decasecond

Playing danger games ONLY at https://twitch.tv/nardandas20. Come and drop by if you want yours played!

The rating period kind of got away from me sadly.

That said I know a lot of games this jam are hectic so if you want the opportunity to relax in a dreamy atmosphere with a little bit of low stakes 3D platforming and farming mechanics I think Marins Dream Garden could serve as a nice pallete cleanser. Also as a bonus here's the reference sheet I hastily made for my marin on day 1 and never posted on here. You can also see the sprite I used for my lats jam entry which also featured Marin! https://ldjam.com/events/ludum-dare/51/marins-dream-garden

I entered Ludum Dare as a "last hurrah" before locking myself down into proper and profitable endeavors. My plan was to build out my portfolio as best I could before I graduate this May. I had a few projects that I've seen as good portfolio builders for someone wanting to get into games. Specifically a game development tool. I wasn't sure what I would make, but since I love Godot, it was probably going to be some kind of Godot tool, likely for the kinds of games I like to make.

But then Ludum Dare came around, and the theme was announced, and I was brainstorming with my (romantic, non-developer) partner. And we came up with the idea of a programmer puzzle type game. That's how This Metal Heart Still Beats came to life.

I had the brilliant idea to make a simple scripting option. I was originally planning on using MoonSharp (C# Lua embedding library) to run Lua scripts that the user wrote. But then the C# builds of my game wouldn't run on the web and I didn't have time to debug it. I switched to GDScript and starting thinking of ways to make the game but without Lua. I realized there is a Graph-Node system built-in to Godot that I could lean on. I just needed a way to translate the node connections into meaninful actions, so I laid the groundwork and put it together as an "event" based system. The idea was events would trigger and the event nodes would receive those events. Then the chain of connections would execute their actions. I had to parse the execution order into something meaningful so I made a basic command system for the back-end that could parse into calling specific functions on the character.

And after the compo, I was able to see that I had just made a scripting language. Sort-of, it was not "complete" and it was quite limited. But it was the start. I knew roughly how to make a scripting language.

I knew that Godot 4 was going to be removing the old VisualScript language and hopefully finding a better solution. So I decided to be the one. I felt that I could do a good job and got down to it. It was called "Choreographer", a mutual on twitter recommended "c11r" for short. It was originally going to be a simple Godot C# addon, but as I got deeper and deeper it eventually became a C++ module for the engine, almost on-par with merging into the engine code itself. But this lower level control let me register the script as a standard language, and file type, and hook into the debugger. It let me write more performant code because it was running compiled C++ instead of C# or worse GDScript (similar to python if unfamiliar).

So here I am, working on a tool, originally planned to be a portfolio builder, now turned passion project, and I still was unemployed, currently a student, and generally down on my luck. But I believed (and still do!). I believed that this project was going to be worth it. I obsessed over all the information I could. I ran a research campaign to get a feel for what the community was interested in. And I looked at the various reasons that the old VisualScript was removed in the first place. And I came to a conclusion that I feel only more experienced developers can. Tools should be specific to the project they are for. That is why so many custom tools exist, and why they sell so well on asset stores. Godot itself is incredibly general purpose. You can make games, software tools, and soon even cinematics. It is powerful in part because of how general purpose it is. And the older VisualScript tried to keep in line with this vision, but became indistinguishable from traditional scripting because of this. I believe that visual scripting should be high-level. It should have specific functions related to the project. Because of this, I realized I needed to have a scripting option that was first-and-foremost, easy to extend for any skill level. I have experience with visual scripting in Unity and Blender, generally with shaders. Godot has visual scripting for shaders as well, but I found writing them out easier to work with personally.

My plan is to make the language extendable in three key ways: - Custom Nodes - Sub-Graphs - Composition

For custom nodes, they would have to be scripted in a traditional language supported by Godot. But this would give them as much power and customization as any experienced programmer would need.

For the sub-graphs, it would be an easy way for any developer to reduce complexity in their visual scripting by turning a segment of their graph into a single node they can use repeatedly.

For composition, this was what felt perfect. Godot uses the "Design By Composition" principle really well and this would continue to play into that. A free-floating node could be added to a graph, and itself would be saved elsewhere as a different graph. And the graph would "inherit" all of the event receivers in the composited graph. And they could be overridden on a case-by-case basis. Or even be called specifically to provide macro functionality. This would let a more experienced developer create a useful collection of reusable code, while allowing a less experienced developer to drop in functionality they want and just change what needs to change.

And if you can't tell by now, I am brimming with excitement over this project. I shouted it to the world and I desperately want to make it a reality. And I'm getting closer to making it a reality every day now. Thanks to some generous donations I'm able to keep up development full-time without needing to find a job elsewhere.

So you can imagine that I completely forgot about Ludum Dare, and that I needed to actively engage to get a ranking. But I wonder if I even want a ranking at this point? As I write the clock is counting down, but I already got what I wanted. I got my prototype. I know what I want to make and how incredibly awesome it could be. I'm happy without a ranking, because even if it got dead last, I know it is exactly what I needed that weekend. It got me to dream again, and this time the dream leaked into reality and I'm just living in it every day.

Thank you for reading my lengthy post-mortum(?). I figured if I'm not getting a rank anyway, it doesn't matter much when I do it. This last Ludum Dare has been a joy to participate in, and I hope you all got what you wanted out of it. Maybe I'll join again next time? Or perhaps I'll be busy getting this new project stable enough to use. Perhaps I could even use it for a game jam someday? That would be something wouldn't it? Take care y'all!

If you want to learn more about c11r, I'd say go to my Twitter. I have a pinned thread with all kinds of info about it.

Game play video

Play the under pressure “Russian roulette” with the hostages, and win the game being very rich you and your accomplice alive !!! Here we are so don’t loose control and try to make the “least bad” choices.

You only have “10sec” to download the game and enjoy ! (No pressure…) :gun:

:video_game: WHO'S NEXT !?

:pencil: Game Page

These games are quick to play and are very close to 20 ratings

https://ldjam.com/events/ludum-dare/51/gridlock

https://ldjam.com/events/ludum-dare/51/office-time-loop-and-the-end-of-the-world

https://ldjam.com/events/ludum-dare/51/10-seconds-old

https://ldjam.com/events/ludum-dare/51/sweetheart-speedrun

https://ldjam.com/events/ludum-dare/51/dimension-rush

https://ldjam.com/events/ludum-dare/51/shabadoo

Hello. Today I have the time in order to rate games - and also explain how I created my project - Shabadoo. Its main particularity is the template which I made so as to simplify the game development. At first I thought that the OLC::PixelGameEngine (Javidx9) could be an interesting way to create my game. I don't know if you know it, but it is a single header file in pure C++ without any dependencies using OpenGL as a way to create inside a GDI+ frame a single texture on which you control every pixel. I quickly resumed how it works, but it is a great tool with many functions and a clever ECS system which reminds us of some Unity script including an appUpdate() section. However (like with Pico-8) there are harsh limitations. Ok! Let's go...

I said to myself that it could be fun to create my own Template for GameJam(s). Fundamentally it is not too hard to create a 2d game engine from scratch in pure C++ and inspired by the PGE template. The core can be developed in less than 500 code lines, but after this work I struggled hard in order to draw, shape and compute game objects. If we can understand easily what a line is (x1,y1 to x2, y2), just a moment think about a hexagon or a filled non-regular polygon... At first, I show you what is a pixel structure according to this template - and how it draws them on screen : ```(c++) struct Pixel { union { // opaque black pixel uint32_t n = 0xFF000000;

        struct
        {
            uint8_t r;
            uint8_t g;
            uint8_t b;
            uint8_t a; // alpha
        };
    };
};

(...)

bool xGameEngine::Draw(const gck::vi2d& pos, Pixel p)
{
    if (!pDrawTarget) 
        return false;

    Pixel d = pDrawTarget->GetPixel(pos);
    // escape quickly if the pixel has the same color
    if (p == d) 
        return false;

    float a = (float)(p.a / 255.0f);
    float c = 1 - a;
    float r = a * (float)p.r + c * (float)d.r;
    float g = a * (float)p.g + c * (float)d.g;
    float b = a * (float)p.b + c * (float)d.b;
    // new pixel at pos
    return pDrawTarget->SetPixel(pos, Pixel((uint8_t)r, (uint8_t)g, (uint8_t)b));
}

When I started my project canvas, I thought about a clean font in-game without any third part. I remembered a script which I made under Unity in order to write text as a single sprite. If you remember TakeYourMedsDarling (a previous entry for the LD 49), I used a system like this... How does it work? In fact, it is more or less similar to the Chip-8 font system (lol). Imagine a sprite 5x7 pixels (chip-8 used a 4x4 pixels size). Imagine now 5 bytes and their bits. For each column the function reads a hexadecimal value and each converted bit 1 becomes a colored pixel - a bit 0 becomes an alpha null pixel. So the letter A can be write with the bits : std::vector keyA{ 0x7E, 0x09, 0x09, 0x09, 0x7E }; For each letter, number or special char, I created them using 5 hexadecimal values. I wasted many time, but this font is mine – and it works as expected giving retro vibes to the game. Take a look at the function – notice how it converts a char to booleans : void xGameEngine::DrawString(gck::vi2d pos, std::string &str, gck::Pixel p, int32_t scale) { // our letters scale - only 5x7 pixels short fontX = 5; short fontY = 7; short pp = pos.x;

    if (stamp == nullptr) 
        DrawFont(fontX, fontY);
    // only lower case
    std::vector<unsigned char> byte;
    transform(str.begin(), str.end(), str.begin(), ::toupper);

    for (size_t i = 0; i < str.length(); i++)
    {
        if (str[i] == '

') { pos.y += (fontY + 1) * scale; pos.x = pp * scale; continue; }

        byte = checkChar(str[i]);

        for (int x = 0; x < fontX; x++)
            for (int y = 0; y < fontY; y++)
                if ((byte[x] >> y) & 0x1)
                    stamp->SetPixel(gck::vi2d(x, y), p); // this one !!!
                else
                    stamp->SetPixel(gck::vi2d(x, y), gck::BLANK);

        DrawSprite(pos, stamp, scale);
        pos.x += (fontX + 1) * scale; // shift to the next char
    }
}

The main difficulty had been to draw some non-regular polygons - the levels on which rebounds the colored balls. It was not too hard to draw a shape, just lines using a main **std::vector** with coordinates (x,y). I could use **std::pair**, but no... However I had no clue how I could fill shapes. There are many ways in order to fill a shape, but they wasted my tiny CPU resources - and as I said I had to use them carefully. Then I saw a raylight in the darkest fog! According to the same **std::vector** I implemented a function which checks all pixels and stores them if they are inside a non-regular polygon coordinates. However I called this function in the appCreate() section - so storing pixels during the first frame, drawing them in the appUpdate() section. The renderer was really smooth - and the resources were saved. // function in order to check if a point is inside a polygon bool xGameEngine::isPointInsidePolygon(std::vector vertices, gck::vi2d pos) { bool isInside = false; auto num_verts = vertices.size();

    for (size_t i = 0, j = num_verts - 1; i < num_verts; j = i++)
    {
        double x1 = vertices[i].x;
        double y1 = vertices[i].y;
        double x2 = vertices[j].x;
        double y2 = vertices[j].y;

        if (((y1 > pos.y) != (y2 > pos.y)) && (pos.x < (x2 - x1) * (pos.y - y1) / (y2 - y1) + x1))
            isInside = !isInside;
    }

    return isInside;
}

```

I really like the background under some games developed using Pico-8. It is like a canvas or a curtain. In my template, I had a function in order to apply a single color to each pixel so as to « clean » the main screen, but I wanted more...

In C++, we can use some ternary operator and I really like it. It is more than a simple condition variable – it allows us to develop some behavior according to a condition. I said to myself that using coordinates I could apply another color to the pixel if it has a particular feature. So I check pixels using this ternary operator :

So I got vertical lines according to the width. Then I found a tip. Simply I add +1 pixel to my game X resolution and it shifts everything on screen. Again I used a ternary operator. Finally I have some zebra lines. Sometimes a little thing can change everything...
``` // clear the entire sprite (or screen) according a specific color void xGameEngine::Clear(Pixel p, Pixel pp, int stripe) { int pixels = pDrawTarget->width * pDrawTarget->height; Pixel* m = GetDrawTarget()->GetData();

    for (int i = 0; i < pixels; ++i)
        stripe != 0 ? (i % stripe ? m[i] = p : m[i] = pp) : m[i] = p;
}

At the end, my template was able to draw many shapes. below you can see every declaration which are explicit : /////////////////////////////////////////////////////// // useful functions declarations /////////////////////////////////////////////////////// inline float map(int s, float a1, float a2, float b1, float b2); inline float computeDistance(const gck::vi2d& p1, const gck::vi2d& p2); inline float lerp(float a, float b, float f); inline vf2d GetVector(int32t nIndex, int32t fRadius, int32t fFactor); vi2d rotatePoint(gck::vi2d p, gck::vi2d axis, float angle); bool inTriangle(const gck::vi2d& p, const gck::vi2d& pos1, const gck::vi2d& pos2, const gck::vi2d& pos3); bool isPointInsidePolygon(std::vector vertices, gck::vi2d px); /////////////////////////////////////////////////////// // functions declarations in order to draw everything /////////////////////////////////////////////////////// virtual bool Draw(const gck::vi2d& pos, Pixel p = gck::WHITE); void DrawLine(const gck::vi2d& pos1, const gck::vi2d& pos2, Pixel p = gck::WHITE); void DrawFrame(const gck::vi2d& pos1, const gck::vi2d& pos2, Pixel p = gck::WHITE, bool fill = false); // simple rectangle void DrawRect(const gck::vi2d& pos, const int32t w, const int32t h, const int& angle = 0, Pixel p = gck::WHITE, bool fill = false); // rotation available void DrawTris(const gck::vi2d& pos1, const gck::vi2d& pos2, const gck::vi2d& pos3, const int& angle, Pixel p = gck::WHITE, bool fill = false); void DrawCircle(const gck::vi2d& pos, const int& fRadius, Pixel p = gck::WHITE, bool fill = false, const int& thickness = 0); void DrawPolygon(const gck::vi2d& pos, const int& fRadius, int32t fFactor, const int& angle, Pixel p = gck::WHITE, bool fill = false); // regular polygon void DrawPolygon(const std::vector vertices, Pixel p = gck::WHITE, bool fill = false); // no regular polygon void DrawSprite(const gck::vi2d& pos, Sprite* sprite, uint32t scale = 1); void DrawFont(int32t x, int32t y); // in order to write string std::vector checkChar(char c); void DrawString(gck::vi2d pos, std::string &str, gck::Pixel p = gck::WHITE, int32t scale = 1); void Clear(Pixel p, Pixel pp = VERYDARKGREY, int stripe = 0); // to clear screen each frame ``` And it is enough so as to create a game :golf:

Among all these functions I really like this one which allows to draw a regular polygon. One single function to draw a square, a pentagon, a hexagon, a heptagon or an octagon - really useful. Take a look at the way in order to fill them. Each edge has two points and the third is the center of the polygon. Then I fill these triangular shapes (as you can see, there is a function to rotate each shape or point) : ``` // check if a point is inside a triangle (used to fill regular polygons) bool xGameEngine::inTriangle(const gck::vi2d& p, const gck::vi2d& pos1, const gck::vi2d& pos2, const gck::vi2d& pos3) { int s = (pos1.x - pos3.x) * (p.y - pos3.y) - (pos1.y - pos3.y) * (p.x - pos3.x); int t = (pos2.x - pos1.x) * (p.y - pos1.y) - (pos2.y - pos1.y) * (p.x - pos1.x);

    if ((s < 0) != (t < 1) && s != 0 && t != 1)
        return false;

    int d = (pos3.x - pos2.x) * (p.y - pos2.y) - (pos3.y - pos2.y) * (p.x - pos2.x);

    return d == 0 || (d < 0) == (s + t <= 0);
}

(...)

// draws a regular polygon according to a single point, a factor and a radius
void xGameEngine::DrawPolygon(const gck::vi2d& pos, const int& fRadius, int32_t fFactor, const int& angle, Pixel p, bool fill)
{
    if (fFactor > 8) 
        fFactor = 8; // beyond 8 it's almost a circle no ?
    // sometimes a point at the center is required
    if (fill) 
        Draw(pos, p);

    for (int i = 0; i < fFactor; i++)
    {
        gck::vf2d vPoint = rotatePoint(GetVector(i, fRadius, fFactor) + pos, pos, static_cast<float>(angle));
        gck::vf2d pPoint = rotatePoint(GetVector(i - 1, fRadius, fFactor) + pos, pos, static_cast<float>(angle));

        fill ? DrawTris(pos, vPoint, pPoint, 0, p, true) : DrawLine(vPoint, pPoint, p);
    }
}

``` I could continue to explain many, many, many things about this template - and especially how I developed the physics for Shabodoo, but I guess that for now it is enough. You can try Shabadoo - and of course you can rate it. Leave a comment - I really appreciate it, and then I have a link in order to rate your own project. I hope that you liked those explanations. If I can improve some parts of my template I will share it on GitHub, but right now it is still bugged and not clearly coded. Stay tuned ++

https://ldjam.com/events/ludum-dare/51/shabadoo

Just a few more votes needed, test out my crappy farming game please :)

https://ldjam.com/events/ludum-dare/51/farming-game

Game: https://ldjam.com/events/ludum-dare/51/toilet-run

10 Seconds till you grow, allowing you to jump higher, but making it harder to get to the end. Hurry before you become too big!

Play our game here:

https://ldjam.com/events/ludum-dare/51/10-second-magic-paintbrush

Hello this is DGSpitzer, I’m the programmer from the team who made 10-Second Magic Artist in LLD 51. Today I want to introduce the tech pipeline and design process we used!

The Original Idea

When we saw the theme “Every 10 seconds”, a lot of different game ideas actually came up during our brainstorm session quite easily. However, most of the ideas are still a bit cliche, or maybe not funny/innovative/theme-oriented enough, as a result we arranged another brainstorm meeting the next day to filter up ideas and to get more discussion around the theme. We always want to find an innovative way to utilize cutting-edge technology into our game. As for myself, I’ve been trying out a lot of different approaches to do AI painting recently. Here is one of the animation video I made with Disco Diffusion AI:

https://www.youtube.com/watch?v=qM0BD2fzyBA

Among all of our ideas, an AI painting game design popped up on our idea ranking list eventually: Let the player scrabble following the NPC clients’ orders, and the NPCs’ demand will rapidly change every 10 seconds. We’ll use AI backend such as Stable Diffusion etc. to convert the player's input scrabble painting with img2img technology, alongside the text prompts created by the NPCs to generate a fancy artwork together! It would be a pretty good way to showcase the boost AI technology could have for human creators, and how it could make everybody’s imagination become true.

Initial Test

Will the result be good? We did a quick test during the brainstorm session, our team members drew one or two very rough sketch in couple seconds by following random prompt sentences being given:

I quickly convert those sketch use Stable Diffusion WebUI:

The result looks pretty promising to us, so we decide it’s a go!

Deployment

I had no experience of deploying a GPU backend or setting up a server - the only similar thing I did before is using Microsoft Playfab to create a simple online leaderboard / inventory system. Therefore it’s quite challenging for me to do it, especially in 72 hours! I dug into the Internet to see what I can do about it… Currently there are several ways to get a GPU server very easily , such as renting a GPU through vast.ai / AWS / Azure etc., or directly using an official API from DreamStudio or other AI drawing platform, in the end considering both my budget, customized ability and convenience, I decide to use banana dev to host a serverless GPU backend.

By default banana does give a one click deploy button for Stable Diffusion AI, however it only supports the txt2img function, it can’t achieve what we want to do in the development. Eventually I used this open source project as a base template to modify: https://github.com/sahil280114/stable-diffusion-inpainting-template/

By modifying it and deploying it through github to the serverless server, we can finally let AI convert! I faced some obstacles during the deployment process though, e.g. I used a customized template, seems like we need to change sanic==22.6.2 in requirement.txt during installation, otherwise the latest sanic version will crash the server side and create a failure deployment, also the log system in banana was not responsive somehow during the game jam, I need to use a temp beta log url for debugging. Each back and forth deployment will take me 1 hour to debug, kinda time consuming in my opinion (but fun to play with).

Unity Front End

For the front end, since the template only has a Python frontend, I need to write my own front end in Unity for sending and receiving data from our remote GPU. Fortunately it does support RestAPI with endpoint https://api.banana.dev/start/v4 The basic RestAPI from banana looks like this:

Additionally, the connection will be held for up to 50s waiting for the output from AI, if times out, I need to use another endpoint https://api.banana.dev/check/v4 with task Call ID from returned json to receive the output.

Normally the inference process from our GPU API is relatively fast (≈4s each output paintings). However, another issue is, our server will shut down if it is idle for a couple seconds, and the next player has to wait 50-70 seconds for the server to warm up and be available again. I then did a trick in our Unity front end, whenever the game starts and timer starts ticking, the game will keep sending an empty request to our API each 20s and let the server start warming up. By the time the players finish and submit their drawings, the API should be ready to use, and after the scene switch animation (5s), our players will get their AI generated artworks immediately in no time!

In the end, that’s how we create the smooth experience for dynamic AI generation in our game!

Would you like to know more? You can try the game out

https://ldjam.com/events/ludum-dare/51/10-second-magic-paintbrush

Guys, there is a JAM game done as datapack for Minecraft (done by @douglas and @icalm). YES, datapack for Minecraft! They already rated more than 27 games but only got around 17 ratings. They had 17 ratings 3 hours ago and within 4 hours rating of games will end. So, it seems unlikely they will get it. If you own Minecraft and know how to work with datapacks (I do not), please consider to help them. :heart:

Thanks everyone who rate my game!

https://www.youtube.com/watch?v=wtVJx2-CMno

*YOU CAN PLAY HERE VIA BROWSER*

Any love is highly appreciated! https://ldjam.com/events/ludum-dare/51/paralland

and still not everything in our trello is marked green!

I have to say that this, by far, has been the most coding I have ever done. What a wacky situation Hurrican Ian pushed me into - this is the largest project I've ever tackled, and the most new knowledge gained.

This isn't much of a post-mortem as it is a mid-mortem:

I've learned a LOT about scope. I tried to help scope our project down when I joined the team, but it still ended up being about an average of 2 or 3 hours for most features - longer when encountering bugs (of which there were many, and a frustrating amount were due to bugs in the Godot engine itself), shorter for easy things.

I learned a lot about the ebb and flow of burnout and its' affects on motivation, and how jumping into something that isn't coding or building scenes in Godot can be the starting point necessary for short-term recovery of motivation; sometimes polishing random assets is the right way to push yourself through the rest of the prototype!

I learned a lot of things about Godot, few of which I can remember off the top of my head. I learned that navigation is hard, especially using deprecated systems because learning the newer one would take too much time away from the real features.

I learned a LOT about teamwork and communicating my needs to my teammate - more-so than college or random team-ups have ever managed to teach me. It let me have the trust that the assets I received would be good, which made coding less stressful.

I learned that Trello automation has monthly quotas (gross), which we reached the limit of late last night (ugh)...

And I learned a hell of a lot about sleep deprivation, between trying to meet the original Jam deadline and trying to work on the project while people are replacing the bricks on my family's house, on the wall right next to my bed and computer desk... Noisy as hell, but I got a recording of the drill sounds and processes it for our game as an SFX, lol.

Long story short, this has been the most grueling and intense yet incredibly fulfilling LD I've participated in.

Would I want to do an Extra entry again? Probably not, at least not one of this scope. Trying hard for two weeks to finish a basic prototype so we could focus on playing&rating other people's games means that, other than the first couple of days where we took a break after the initial crunch weekend, we haven't really gotten around to many other games... and even now, I'm exhausted just looking at the few tabs I had open for the past two weeks.

Would I want to work with @shreemp on a jam entry again? Absolutely!

Now it's time to take the rest of October to recover - after that, maybe we'll continue our game, maybe we'll start something new together, who knows?

For now, I hope everyone else has had a great jamming season - and I look forward to doing it all again come January! Let's all start the New Year off strong together!

Bill is in home office. Sounds relaxing? Well it is not with his boss, who expects Bill to check in with him every 10 seconds.

On top of that Bill has a long list of chores to be done. Will he able to get it all done while also not angering his boss?

Walk with [WASD]. You can carry and drop objects and write your boss with [E] or [Space].

[Play now] or [Rate]