[IMG]http://www.facepunch.com/fp/ratings/tick.png[/IMG]Agree for Trees 1:
[IMG]http://s18.postimg.org/aorsr01ax/trees1.png[/IMG]
[IMG]http://www.facepunch.com/fp/ratings/cross.png[/IMG]Disagree for trees 2:
[IMG]http://s18.postimg.org/vzpcv9jfd/trees2.png[/IMG]
I'm leaning toward the first one. It just mixes better IMO, but I'm still torn.
[QUOTE=Xystus234;47526953][IMG]http://www.facepunch.com/fp/ratings/tick.png[/IMG]Agree for Trees 1:
[IMG]http://s18.postimg.org/aorsr01ax/trees1.png[/IMG]
[IMG]http://www.facepunch.com/fp/ratings/cross.png[/IMG]Disagree for trees 2:
[IMG]http://s18.postimg.org/vzpcv9jfd/trees2.png[/IMG]
I'm leaning toward the first one. It just mixes better IMO, but I'm still torn.[/QUOTE]
The 1 look way too deterministic and and unnaturally even. The second ones look more like an actual forest.
[QUOTE=Xystus234;47526953][IMG]http://www.facepunch.com/fp/ratings/tick.png[/IMG]Agree for Trees 1:
[IMG]http://s18.postimg.org/aorsr01ax/trees1.png[/IMG]
[IMG]http://www.facepunch.com/fp/ratings/cross.png[/IMG]Disagree for trees 2:
[IMG]http://s18.postimg.org/vzpcv9jfd/trees2.png[/IMG]
I'm leaning toward the first one. It just mixes better IMO, but I'm still torn.[/QUOTE]
I feel there's more contrast with the second one, since the trees in the first one blend into the map too much, making it look like cabbages or bushes or the like. I'm not too fluent with art but I'm not sure if the composition is too dark (I don't see much brights).
Also, I got VERY basic networking done. No server-side position handling, that'll be done in the future when I feel like reworking it :v: for now the client sends the server it's position every like 0.2 seconds while they're moving, which broadcasts it to every other client. Gonna work on interpolating positions so the client's new position is smooth instead of jumping to the new one.
[t]https://dl.dropboxusercontent.com/u/9580892/network.png[/t]
Just need an actual model for players, the black boxes make it confusing to see what is what.
[QUOTE=Awesomecaek;47526978]The 1 look way too deterministic and and unnaturally even. The second ones look more like an actual forest.[/QUOTE]
The problem is that the outlines look like shit when compared to the rest of the map:
Combination of 1 and 2:
[IMG]http://s12.postimg.org/ttasotr0t/shit.png[/IMG]
Just 1:
[IMG]http://s4.postimg.org/6zol38avh/notshit.png[/IMG]
I know you're working on trees, but I have to mention that somehow the water doesn't feel right now to me. The grass and sand remind me of 3d games' texture fidelity, but the water feels too textured rather than a subdued thing.
Idk I just get this whole really rough and gritty feeling whenever I see your game. I like seeing you post it and want to see more every time, but from the HUD to the world every part of it feels really textured and gritty.
Like my eyeballs are visually feeling sandpaper for the sake of feeling something real. I like the feeling of sandpaper, but I want some smoothness in there, too, and some other visual feel as well.
When I look at the grass, I think, wow nice that feels like grass in my head, and the sand gives off a sand feel, too, I think. But the trees have this stone feeling to them, and the water reminds me of leather and the HUD feels like carved marble but not finished to the touch, and it's really confusing.
If I could lick your HUD I'd expect it to be really salty. There's a lot of weird synesthetic feelings I get looking at those posts. None of this is a bad thing I don't think. I just feel like if I could eat your game it would be like salty rock candy. Or something.
[editline]14th April 2015[/editline]
Look dude, I don't know man, I didn't have breakfast.
Settling on this, yea or nay.
[IMG]http://s12.postimg.org/f1z2hlkp9/final.png[/IMG]
If it looks like garbage, please tell me. My eyes are horrible.
I just finished reading [URL="http://learnyouahaskell.com/"]Learn You a Haskell for Great Good![/URL]
So now when you ask me "What's the difference between an applicative functor and a monad?" instead of merely shrugging my shoulders and shaking my head I will press my fingers to my temples and groan in pain.
[QUOTE=Xystus234;47527331]Settling on this, yea or nay.
[IMG]http://s12.postimg.org/f1z2hlkp9/final.png[/IMG]
If it looks like garbage, please tell me. My eyes are horrible.[/QUOTE]
Have you tried brightening it a bit? Right now it's a little dark. Not just the trees, everything in the game.
[QUOTE=Xystus234;47527331]Settling on this, yea or nay.
[IMG]http://s12.postimg.org/f1z2hlkp9/final.png[/IMG]
If it looks like garbage, please tell me. My eyes are horrible.[/QUOTE]
Too dark. It looks like it's perpetually stormy.
[IMG]http://s12.postimg.org/ug8dfrll9/brighter2.png[/IMG]
Better? Tweaked the post processing.
I have a dumb noob fear of cloud storage services like Dropbox running this scenario:
Develop program on PC and Laptop. PC saves new version to Dropbox. Log onto laptop. Laptop updates the dropbox instead of downloading it and overrides the new version with the old one.
Why doesn't this happen?
(This may be the wrong thread but I consider this the closest thing to "Casual programming chat/ Questions too small for a thread" thread.)
[QUOTE=Larikang;47527408]I just finished reading [URL="http://learnyouahaskell.com/"]Learn You a Haskell for Great Good![/URL]
So now when you ask me "What's the difference between an applicative functor and a monad?" instead of merely shrugging my shoulders and shaking my head I will press my fingers to my temples and groan in pain.[/QUOTE]
The difference between applicative and monad is the difference between ap (<*>) and bind (>>=).
Let's also add the plain functor to the mix.
fmap :: (a -> b) -> f a -> f b
(<*>) :: f (a -> b) -> f a -> f b
(>>=) :: (a -> m b) -> m a -> m b (reordered to make similarities more clear)
Now here's how you can interpret those signatures.
The functor allows you to apply a transformation to the values inside of some context. After the mapping, the context might change but you as the user don't have any control over HOW it changes.
Applicative lets you use your transformation AND allows you to supply your own context. Then it takes the existing context and values in it (f a) and produces f b by combining your context with the existing one and applying your transformation to the existing values.
This is stronger than before because we get a say in what the resulting context will look like.
For example, if you have a Maybe a, by mapping over it you have no control over weather the result will be Just a or Nothing. It will depend on what it was before the mapping.
With applicative however you do have some control. Nothing <*> Just 5 will result in Nothing.
Now monads, they give you even more control.
You can still transform the values in the existing context, and you can still provide your own context, but this time, the context you provide can actually depend on the values that were already present.
For example, you could write something like `Just 5 >>= (\n -> if n < 3 then Nothing else Just n + 1)`. Depending on the value we had before (the 5) we can change the context to a Nothing or we can keep the Just.
In a chain of ... <*> ... <*> ... <*> ... you could determine what the resulting context will be without ever knowing what the values were at the start or how they were transformed. On the other hand, with ... >>= ... >>= ... you don't have a clue.
[QUOTE=Darwin226;47527643]The difference between applicative and monad is the difference between ap (<*>) and bind (>>=).
Let's also add the plain functor to the mix.
fmap :: (a -> b) -> f a -> f b
(<*>) :: f (a -> b) -> f a -> f b
(>>=) :: (a -> m b) -> m a -> m b (reordered to make similarities more clear)
Now here's how you can interpret those signatures.
The functor allows you to apply a transformation to the values inside of some context. After the mapping, the context might change but you as the user don't have any control over HOW it changes.
Applicative lets you use your transformation AND allows you to supply your own context. Then it takes the existing context and values in it (f a) and produces f b by combining your context with the existing one and applying your transformation to the existing values.
This is stronger than before because we get a say in what the resulting context will look like.
For example, if you have a Maybe a, by mapping over it you have no control over weather the result will be Just a or Nothing. It will depend on what it was before the mapping.
With applicative however you do have some control. Nothing <*> Just 5 will result in Nothing.
Now monads, they give you even more control.
You can still transform the values in the existing context, and you can still provide your own context, but this time, the context you provide can actually depend on the values that were already present.
For example, you could write something like `Just 5 >>= (\n -> if n < 3 then Nothing else Just n + 1)`. Depending on the value we had before (the 5) we can change the context to a Nothing or we can keep the Just.
In a chain of ... <*> ... <*> ... <*> ... you could determine what the resulting context will be without ever knowing what the values were at the start or how they were transformed. On the other hand, with ... >>= ... >>= ... you don't have a clue.[/QUOTE]
I read the same book, and am currently groaning and pressing my fingers against my temples.
[img]http://i.imgur.com/oGXhBYV.png[/img]
Rohbot client written in C++ using pdcurses..
[QUOTE=General J;47527642]I have a dumb noob fear of cloud storage services like Dropbox running this scenario:
Develop program on PC and Laptop. PC saves new version to Dropbox. Log onto laptop. Laptop updates the dropbox instead of downloading it and overrides the new version with the old one.
Why doesn't this happen?
(This may be the wrong thread but I consider this the closest thing to "Casual programming chat/ Questions too small for a thread" thread.)[/QUOTE]
Timestamps.
[editline]14th April 2015[/editline]
Also even if it did that, you can return the previous version from the web interface.
[QUOTE=General J;47527642]I have a dumb noob fear of cloud storage services like Dropbox running this scenario:
Develop program on PC and Laptop. PC saves new version to Dropbox. Log onto laptop. Laptop updates the dropbox instead of downloading it and overrides the new version with the old one.
Why doesn't this happen?
(This may be the wrong thread but I consider this the closest thing to "Casual programming chat/ Questions too small for a thread" thread.)[/QUOTE]
This has actually happened to me before. No idea how I managed to do it but it did.
Needless to say I was not happy opening up my files and seeing old information, go back to other computer and find that it was already updated. :suicide:
[QUOTE=Darwin226;47527643]The difference between applicative and monad is the difference between ap (<*>) and bind (>>=).
Let's also add the plain functor to the mix.[/QUOTE]
To be clear, I think I do understand the difference having read the book.
But that doesn't make the pain go away.
On OneDrive if there's a conflict that can't be resolved with the timestamps it'll upload both files with the duplicate named "filename-computername.ext".
[QUOTE=Larikang;47528018]To be clear, I think I do understand the difference having read the book.
But that doesn't make the pain go away.[/QUOTE]
I don't think it ever does. You just learn to live with it.
[QUOTE=General J;47527642]I have a dumb noob fear of cloud storage services like Dropbox running this scenario:
Develop program on PC and Laptop. PC saves new version to Dropbox. Log onto laptop. Laptop updates the dropbox instead of downloading it and overrides the new version with the old one.
Why doesn't this happen?
(This may be the wrong thread but I consider this the closest thing to "Casual programming chat/ Questions too small for a thread" thread.)[/QUOTE]
Why exactly it happens I don't know, but I really suggest you use SVN / Git / other version control systems instead of Dropbox...
Just nailed an interview for a scholarship for college showing some of my projects.
[b]Edited to get on topic[/b]
Use source control as soon as you can. It prevents cloud storage folder hell.
[QUOTE=MrFancyBuns;47529322]Just nailed an interview for a scholarship for college showing some of my projects.
[b]Edited to get on topic[/b]
Use source control as soon as you can. It prevents cloud storage folder hell.[/QUOTE]
Pretty sure my projects got me a lower conditional offer for university too, it's great to get recognition :dance:
I have never gotten any recognition for my work, but hey, at least I have 1,276 GitHub stars! :v:
[QUOTE=Berkin;47529551]I have never gotten any recognition for my work, but hey, at least I have 1,276 GitHub stars! :v:[/QUOTE]
I think that's some sort of recognition...
Picked up a Moto 360 since they went on sale, figured it'd be fun to try and make some watch faces for it. Currently making a Pip-Boy watch face.
[t]http://i.imgur.com/UfHSSpl.jpg[/t]
[QUOTE=Darwin226;47527643]The difference between applicative and monad is the difference between ap (<*>) and bind (>>=).
Let's also add the plain functor to the mix.
fmap :: (a -> b) -> f a -> f b
(<*>) :: f (a -> b) -> f a -> f b
(>>=) :: (a -> m b) -> m a -> m b (reordered to make similarities more clear)
Now here's how you can interpret those signatures.
The functor allows you to apply a transformation to the values inside of some context. After the mapping, the context might change but you as the user don't have any control over HOW it changes.
Applicative lets you use your transformation AND allows you to supply your own context. Then it takes the existing context and values in it (f a) and produces f b by combining your context with the existing one and applying your transformation to the existing values.
This is stronger than before because we get a say in what the resulting context will look like.
For example, if you have a Maybe a, by mapping over it you have no control over weather the result will be Just a or Nothing. It will depend on what it was before the mapping.
With applicative however you do have some control. Nothing <*> Just 5 will result in Nothing.
Now monads, they give you even more control.
You can still transform the values in the existing context, and you can still provide your own context, but this time, the context you provide can actually depend on the values that were already present.
For example, you could write something like `Just 5 >>= (\n -> if n < 3 then Nothing else Just n + 1)`. Depending on the value we had before (the 5) we can change the context to a Nothing or we can keep the Just.
In a chain of ... <*> ... <*> ... <*> ... you could determine what the resulting context will be without ever knowing what the values were at the start or how they were transformed. On the other hand, with ... >>= ... >>= ... you don't have a clue.[/QUOTE]
This is totally alien to me
My list of "stuff to one day look up and learn about" is growing faster than I get through it :v:
[QUOTE=MrFancyBuns;47529322]Just nailed an interview for a scholarship for college showing some of my projects.
[B]Edited to get on topic[/B]
Use source control as soon as you can. It prevents cloud storage folder hell.[/QUOTE]
Congratulations.
My advice, assuming your degree allows it. Take something completely different to prevent yourself from burning out, something not on a computer. I was doing just computing subjects for the first year and was hating it.
I'm taking Mandarin this year and it really helps to not be sitting in front of a computer all day, I'm thinking of getting a joint degree and might even travel to China to do some study. It'll take an extra year but I think it's worth my sanity.
Tried to make the files to be represented by 'plants' instead, because the walking animation code is too convoluted to make it work well with collision system of the file buildings. Setting up the collision seems to slow down the world generation by the multifold with the old collision system I used.
Probably will come back to integrate the walking code and collision system when I had ample time to get it done in one go. Right now real life work is eating up any free time I had.
Do you think this kind of scene is expandible/fun to play around in?
The player is the middle:
[IMG]http://i.imgur.com/PQnwKzb.png[/IMG]
With the file names visible:
[IMG]http://i.imgur.com/4mnFMaG.png[/IMG]
Or is the old setting more engaging instead?
[IMG]http://i.imgur.com/sFaahX2.png[/IMG]
[QUOTE=Berkin;47529551]I have never gotten any recognition for my work, but hey, at least I have 1,276 GitHub stars! :v:[/QUOTE]
Well I mean there's that Microsoft tweet.
[editline]14th April 2015[/editline]
[QUOTE=hakimhakim;47530097]-files-[/QUOTE]
Definitely like the old, it's more tangible.
[QUOTE=Ott;47530112]Well I mean there's that Microsoft tweet.[/QUOTE]
Weirdly enough, Hacker News/Reddit got me a lot more traffic than Microsoft did. But @msdev posts tons of projects every day, so it doesn't surprise me that much. I still thought it was neat, even if it didn't get much attention.
I think my lack of an unmanaged port turns a lot of potential users away, especially those developing on platforms where a .NET/Mono runtime isn't available. I just don't have the patience for learning C++; too much can go wrong with the smallest mistakes.
Sorry, you need to Log In to post a reply to this thread.
