gren

addictive game

aha! not anymore now that we know ;-D

Is there any statistical/probabilistic explanation of why the answer is almost 100'000 ?

Profile and identify bottleneck?

Geohash looks brillant!

just come to my kitchen garden.

how is that possible?

The install procedure is a bit complex, this should just be done with a "npm install -g ..".

Especially the install.sh only works on Linux.

Otherwise very cool idea :-)

I was also perplex the first time I entered this project. You would be surprise how this simple rules is already quite challenging. This game is fully observable and also determinist, which give way to make much more complex AI I think. I see it a bit like Chess: Pretty simple rules but there is still a fight to have the best AI in chess.

This game is fully observable and determinist so that is not the hardest situation. However there is still a lot of possible game states.

I've started an attempt to have a tree of all possible actions and using a minimax algorithm (with a score function + alpha-beta pruning) but this is not yet conclusive because I can't explore so much deep (was able to explore up to 20 next player decisions but that is just 5 moves of your hero).

I think this game is enough simple to try to have this approach but also challenging because there is still up to 5 possible actions per turn so it is a max of 5^1200 total of possible state for a game – a lot.

My current approach is now to try to have a minimax with pre-explored interesting path in the tree (e.g. all path which leads to tavern and mines), that is still a lot of computations.

There is already! However it is not yet filtered in the current homepage but this will be ASAP.

as a proof: https://glsl.io/transition/a830822b23e846e25d2d

see that there is already some warnings ;-)

99 lines of code . . . and a few libraries. ;-)

Anyway, nice bunch of new ES6 features out there

I'm a bit skeptical about this new property.

In this basic example,

    .element:hover {
	will-change: transform;
    }
    .element:active {
	transform: rotateY(180deg);
    }

it seems very predictable. I don't get why the browser couldn't guess (with some heuristics) what to prepare.

Also I feel we will misuse this feature and tend to make the performance worth than if the browser would detect what are the "will-change"s.

is there any goal?

exactly! definitely planned https://github.com/glslio/glsl.io/issues/23 :-)

https://github.com/glslio/glsl.io : the platform itself is open-source.

https://www.youtube.com/watch?v=BYdCNTJaGss : a first presentation video.

An other common mistake when you begin with promise:

    var result = promise.then(identity, function (error) { console.log(error); })

Oops, you just recovered your promise with undefined. result will always be successful. Yes if you don't throw again (or return a new failure promise) in your error callback it will make the resulting promise successful.

I haven't checked if this behaviour is the same on the DOM Promise API but it is on Q (which is the most popular JS lib for Promises).

dead link

Me too :-)

very useful nowaday!