For Rain World, the whole narrative kicks off because you're a slugcat who's lost his family, right? Not sure how feasible it would be, but could you make that a tutorial? A "monkey see, monkey do" kind of thing? Traveling with an older/slugcat partner going through a linear area, the other slugcat performing moves and such, thus demonstrating to the player what to do?

Ideally, yes! This was my first suggestion waaaay back when we were starting the tutorial stuff, but apparently Rain World's character movement and AI are done in a manner thats completely opposite to "sockpuppeting": the movement AI is completely tied to pathfinding and a million other systems, so we can't just plop in another slugcat and ask it to act without rebuilding a bunch of super low level systems. Very annoying, but also not atypical for "Rain World problems." With our tools and engine it's easy to do weird Rain Worldy stuff, and hard to do normal basic gamey stuff.

 

One way to do this is to record your inputs and simulate another player using those inputs. Obviously you can tweak the inputs before giving them to the computer player. This player basically has the same interface as a player but you just hook up the controls to a list of inputs instead of actual computer inputs, where it fetches a new one from the list every game loop tick.

Maybe have the tutorial be about your parents teaching you how to survive?

Dad and Mom Slugcat sounds neat to me.

I would play this.

Thanks for the explanation of idempotence!

Yep yep, I get that random.value returns a value 0-1  So

return Random.value < 0.45f;

has a 45% chance of returning true, right?

and

return Random.value < Mathf.Pow(0.5f, 2);

is 25%, or equivalent to flipping a coin twice and getting side A both times. What I'm after thought is the chance of flipping a coin twice and getting A any time. That's what I did the Math.Pow(1f/chance) thing for, but looking at it again either of these

return Random.value > Mathf.Pow(0.5f, 2);

or

return Random.value < 1f - Mathf.Pow(0.5f, 2);

would seem more reasonable, as they do have the 75% chance we're going for...?

You want to get the chance of any one roll being true of n rolls, correct?

the chance is then, with the chance of success being p, P(>0)=1-(1-p)^n
So the function should return
Random.value<1f-Mathf.Pow(1f-p,n)

if you instead define p as the chance of failure, obviously the probability then becomes
P(>0)=1-p^n
in which case the function should return
Random.value<1f-Mathf.pow(p,n)

But looking at this part of your post

for (int i = 0; i < time; i++)
            if (UnityEngine.Random.value < chance)
                return true;
        return false;

I would say the first case is the one you're trying to implement, so
function foo{
return Random.value<1f-Mathf.Pow(1f-chance,times)
}

for the walking animation, I'd make the front leg extend diagonally down instead of horizontally, cause that's not how legs work

[Update 518]

Update 518

Sleep screen and map swarm room indicators coming along!



Probably don't have to mention that the illustration and the button are place holders...

Looks amazing 

[As long as you're using the palette to make the world be what you imagine it to be]

Any better?

Looks dope, albeit gloomy. But if that's the mood you're going for in this scene it works. It's all about whether you want that bright saturated look or not.

IF you want the bright look, you could try using the old background colors and only changing the foreground, but that's completely up to you. As long as you're using the palette to make the world be what you imagine it to be.

The difference in resolution between foreground and background clashes, especially with the black outlines on the characters. I would recommend making characters lower res OR removing/changing the character outline to a colour that fit in with the overall palette.

The other option would be to make the background higher res, but the background feels stronger and contributes more to the overall aesthetic at this point.

Hälsningar från finland!

ok, finally finished the devlog! Bit late to the party, but I'm here! Man, so close(?) to release too.

I will provide some input now whether you like it or not, and I know it probably won't matter since you've finished most things!

ok, critique:
The deer I feel is off. The legs drag too close to the ground when moving, I feel like they should retract more before extending again for each step. Also sometimes it seems as though its center of gravity is not within the area of it's feet on the ground, taking 3 dimensions into account. It looks slightly weightless.

The plants could really do with not being static

If you still have that jump sound, change it.

That's all I have to critique! The rest is fucking beautiful . I can honestly say this is the most I've ever anticipated a game, and you've also inspired me so much.

 Ax = Ax - (getToDiag-diag)*dirX*0.5
  sAx = sAx - (getToDiag-diag)*dirX*0.5
  Ay = Ay - (getToDiag-diag)*dirY*0.5
  sAy = sAy - (getToDiag-diag)*dirY*0.5
  Bx = Bx + (getToDiag-diag)*dirX*0.5
  sBx = sBx + (getToDiag-diag)*dirX*0.5
  By = By + (getToDiag-diag)*dirY*0.5
  sBy = sBy + (getToDiag-diag)*dirY*0.5
function end

What you see is, separated by the empty rows: Adding the velocities to the positions, applying air friction and gravity to the velocities, retrieving the data necessary for the "binding" of the two points, and finally applying the bond. The points are now freely moving, but will always keep the same distance to each other, and forces applied to one point will realistically transfer into the other. As long as you draw the points after this has been done, they will always be displayed with the correct distance between them.

You see the "0.5"s after each row in the last section? Those mean that if there is a difference between the desired distance and the actual distance between the points, this point will stand for  50% of the movement made to correct the distance. If you tilt those numbers, so that for example point A stands for 85% of the movement and point B for 15% it will appear that B is significally heavier than A. If you make it so that the sum is less than 100% you will get an elastic bond, like a rubber band. You might want to tone down the movement of the actual positions in this case, and focus on the velocities. Other interesting choices you can toy with is to only affect the points if they are further away from each other than the desired distance, or only if they are closer.[/size]

What you're describing is a proportional controller! This is like THE most useful tool for making smooth graphical transitions and generally making stuff get where you want it, it's also great for smooth menugraphics.

For future reference, you might want to look into controllers in general (It's one of the best uses for video games I've gotten out of my unfinished engineering degree), there's P-controllers (proportional), I-controllers (integrating) and D-controllers (derivating). You can combine them for something called a PID-controller and oh boy stuff just moves like a charm.

The controller itself is usually one line of code which uses the error function, which is what you describe as:

difference between the desired distance and the actual distance between the point

for a proportional controller you just move the variable being controlled with the error function multiplied by a constant, but as the error function gets smaller, you're moving things less, so you may need to add:
 - an integrating component, which will sum up all the error functions for each step (tick) and use that value multiplied with a constant to get closer to the reference value (if this component is too strong you will end up with some springy behavior, which might even be desirable).

OR

 - a derivating component, which takes the derivative of the error function being controlled and multiplies that by a constant. Basically think of this as slowing down before coming to a red light, your speed (derivative of position, also the part of the derivative of the error function (r-position)) is high, so you add less position to your variable (position).

basically the line will look like this:

derivative=variable-oldvariable //or whatever way you want to calculate the derivative
error=reference-variable
integral+=error   //integral would be (probably) an instance variable
variable+=error*constant1+integral*constant2+derivative*constant3

integral will have to be set to 0 if you reset the variable or manipulate it, otherwise it will have "charged up" with the errors from before
You might want constant3 to be negative


wow, that's a lot of text! It's all hoping it might help you! Joar, you are an incredibly talented programmer, and you've done things I'd never dream of tackling (at least before reading this devlog). Then reading through the devlog you sometimes ask questions about something that I thought must have been obvious to you. Don't take this the wrong way but that inspires me. Never stop being amazing guys.