23:08 < hansihe> rom1504: it is transparrent
23:08 < hansihe> there are blocks all around me randomly
23:09 < redstonehelper> can you see those?
23:09 < hansihe> thats just how it looks like when looking down in the void
23:09 < hansihe> no, can't see any blocks
23:09 < hansihe> and yes, i can move just fine, not doing anything with the packets tho
23:09 < rom1504> hansihe: if you go in gamemode 0 or 1, can you move ? (i.e. are you sure you are not stuck in the wall ?)
23:10 < hansihe> i am not, only the lower 16 blocks are filled, i spawn the player at height 60
23:10 < rom1504> setting skylight to 0 usually give weird things though
23:10 < hansihe> i could spawn the player in another gamemode i guess, you think it would help?
23:11 < hansihe> https://usercontent.irccloud-cdn.com/file/40VJB3ig/f3a
23:12 < redstonehelper> hansihe: you are at y=13
23:12 < redstonehelper> ok now that's transparent
23:12 < hansihe> there is f3+a and proff that it's outline only
23:12 < hansihe> yeah, last was a bad picture
23:12 < redstonehelper> do you know what f3+a does?
23:12 < redstonehelper> because I don't see f3+a in that picture
23:12 < redstonehelper> and I would be surprised to see f3+a anyway :D
23:13 < hansihe> i guess i may have misunderstood, did alt+f3 and the bar graph showed up :P
23:13 < rom1504> I never saw that transparent block thingy
23:14 < rom1504> but then the server can produce any number of bugs in the client
23:14 < rom1504> (including any kind of crash)
23:14 < hansihe> yep
23:14 < redstonehelper> hansihe: hold f3 and press a, it reloads/rerenders chunks client-side
23:15 < hansihe> doesn't seem to help
23:15 < hansihe> i'll try fiddle with the data i'm sending
23:15 < hansihe> see if anything changes
23:17 < hansihe> https://usercontent.irccloud-cdn.com/file/cGiURxdB/f3b
23:17 < hansihe> fixed it lol
23:17 < hansihe> that was easy
23:17 < redstonehelper> what'd you change?
23:17 < hansihe> i wasn't sending skylight in the initial chunk packet, seems like that's what the client does
23:18 < hansihe> seems like the client wants that*
23:18 < redstonehelper> weird
23:18 < redstonehelper> it updates lighting on its own randomly too
23:19 < hansihe> guess it's time to fix the off by 1 error that's causing the gaps then, thanks for the help!
23:20 < rom1504> hansihe: in what language is your server ?
23:20 < hansihe> erlang!
23:20 < rom1504> not java I hope, that's boring :-°
23:20 < hansihe> or elixir
23:20 < rom1504> ah cool
23:20 < hansihe> with the chunk parts written in rust
23:21 < hansihe> so yeah, it's a nice mix :P
23:21 <+clonejo> did someone say erlang? *looks around*
23:21 < hansihe> o/
23:21 <+clonejo> is there some rust lib to write erlang modules in rust?
23:21 < hansihe> server is at https://github.com/hansihe/McEx
23:21 < rom1504> oh really, why not the chunk part in elixir too ?
23:22 < hansihe> clonejo: there is now lol
23:22 <+clonejo> ^^
23:22 < hansihe> clonejo: https://github.com/hansihe/Rustler
23:22 <+clonejo> nice
23:22 < redstonehelper> I know some of these words
23:22 < hansihe> rom1504: i tried doing it, its just horrible to work with mutible state, and you can't really do it efficiently
23:23 < hansihe> i mean the chunk data obviously
23:23 < rom1504> okay
23:23 < hansihe> the server repo is outdated btw, i have more stuff locally
23:24 <+clonejo> hansihe: well, you can use references to parts of binaries
23:24 < hansihe> clonejo: yeah, but that doesn't really help when you want to set one block in a chunk :)
23:24 <+clonejo> you create a copy referencing the unchanged parts and containing the change.
23:25 <+clonejo> its not very ergonomic though
23:25 <+clonejo> performance is probably okay
23:25 < hansihe> i started to do something like that i think, it became very ugly
23:25 <+clonejo> hansihe: have you seen my erlang mc server?
23:25 < hansihe> it probably would have worked though
23:25 < hansihe> clonejo: don't think so
23:25 <+clonejo> https://github.com/clonejo/mc-erl
23:26 < hansihe> oh, i have seen that, yes!
23:27 < hansihe> i looked at how you structured some of the code when i first started my project
23:27 <+clonejo> i was quite new to erlang back then
23:27 < hansihe> this was my first elixir project as well
23:29 < hansihe> but yeah, that's very cool, i didn't realize you where in here :)
23:29 <+clonejo> well, i'm just idling. but i have a highlight on erlang …
23:29 <+clonejo> if i wanted to do an mc server today i'd probably also do it in erlang+rust
23:30 < hansihe> that's the reason why i wrote the nif wrapper thing
23:30 < hansihe> so that i can write the heavy duty mutable state stuff in native code without risking segfaults
23:30 <+clonejo> but i'm not really into custom mc servers anymore. a custom implementation of a minecraft-like engine (both server and client) would be interesting though
23:30 < hansihe> yeah
23:31 < hansihe> i used to run a minecraft server before, the main problem was chunk generation/stuff taking up a lot of resources
23:31 <+clonejo> is the mc client still sending state instead of user input?
23:32 <+clonejo> also using floats is totally stupid, float arithmetic yield different results on different computers
23:32 < hansihe> one of the most interesting things with an erlang server is that you could probably easily move the chunk servers over to another box
23:32 < hansihe> clonejo: yep
23:33 < hansihe> clonejo: here is the full protocol specification https://github.com/hansihe/McEx/blob/master/lib/net/packets.ex#L146
23:36 <+clonejo> nice, a macro for packet definitions
23:37 <+clonejo> would have done that, but in erlang that's quite painful
23:37 < hansihe> looking back at it, it's a bit ugly
23:37 < hansihe> but the dsl is nice
23:37 < hansihe> but yeah, elixir macros seem to be perfect for that kinda stuff
23:38 <+clonejo> yeah. i had kind of a dsl too, but it is interpreted at runtime
23:55 < hansihe> it's actually not that hard to do some ghetto terrain generation :) https://usercontent.irccloud-cdn.com/file/Fue5E484/2016-01-18_23.54.09.png
23:58 < rom1504> "ghetto" being the main word here :p
--- Day changed mar. janv. 19 2016
00:01 < hansihe> :P
00:03 < hansihe> to be fair it looks at least twice as good when it's grass
00:04 < rom1504> if you want to display some more interesting stuff while you don't have a good terrain generation (which might not be so easy). I found loading schematic to be fairly easy and it gives and interesting end result
00:04 < rom1504> providing you have an nbt lib in your language
00:04 < rom1504> http://download.rom1504.fr/minecraft/mc-fs-cow.png
00:05 < rom1504> that also tests the perf of your world/chunk module
00:06 < rom1504> well, doing simple generation is easier of course
00:07 < rom1504> (but reading a schematic file is much easier than reading an anvil file for example)
00:09 < hansihe> that's a very good idea
00:10 < hansihe> i do have a nbt lib, yes, should be fairly easy to do that then
00:11 < rom1504> the spec of the schematic nbt is there http://minecraft.gamepedia.com/Schematic_file_format and you basically only need Blocks and Data
00:12 < rom1504> (I mean first read the nbt using your nbt lib, then you can read the blocks in Blocks key and put them in your world)
00:12 < rom1504> (oh and you need Width Height and Length of course too)
00:12 < rom1504> I just did that in my server and it was fun
00:16 < hansihe> i'll probably do it after i get the player stuff fully working 
00:16 < hansihe> i might just find some open source terrain generation mod and bootleg the algorithm or something though
00:17 < rom1504> yeah I'd be interested by such an open source terrain generator too. I guess there must be a few
00:17 < hansihe> idk if there are any
00:18 < rom1504> the big open source servers probably have something, now idk how far along they are
00:19 < rom1504> say cuberite or glowstone
00:19 < hansihe> i suppose
00:19 < rom1504> and got to dig through their code
00:19 < rom1504> well https://github.com/cuberite/cuberite/tree/master/src/Generating
00:19 < hansihe> although getting some decent grassy hills generation should not be that difficult
00:19 < rom1504> "bootleg the algorithm" might not be trivial :d
00:20 < hansihe> was just about to say...
00:20 < hansihe> haha
00:20 < rom1504> hansihe: yeah I have that in my server (the hill generation part)
00:20 < hansihe> rom1504: what's you server called?
00:21 < rom1504> https://github.com/PrismarineJS/flying-squid/blob/master/src/lib/worldGenerations/diamond_square.js that's not so long
00:21 < rom1504> flying-squid
00:21 < hansihe> ah, nice
00:21 < hansihe> how is the performance in js?
00:22 < rom1504> it's okay, but generation do take some cpu, and saving chunks to anvil too
00:23 < rom1504> going forward we'll probably separate the world instance in its own service or something. Well if we want to make the server scale better anyway
00:23 < hansihe> yeah, i guess it wouldn't be too bad
00:24 < hansihe> the cool part about erlang is that every single one of my loaded chunks are a process
00:24 < hansihe> the vm also runs on all cores on the machine
00:25 < rom1504> (that's how generation look currently http://download.rom1504.fr/minecraft/mc-generation.png which is ok but nothing like vanilla ^^)
00:25 < rom1504> hansihe: ah yeah that's cool
00:26 < hansihe> yeah, that generation is not bad at all for testing
00:27 < rom1504> io is done in separate threads in node.js, but the rest is done in 1 thread, so for example generation and parsing/serializing the anvil files can be blocking if too much of that is done at once
00:27 < hansihe> i see, yeah
00:27 < rom1504> so we'd have to do specific things to use several threads
00:28 < hansihe> erlang runs one scheduler on each core by default, each scheduler runs one process at the time
00:28 < hansihe> the only way processes can communicate is by messaging
00:29 < hansihe> processes are also extremely light, you can run hundreds of thousands of them without much issue
00:30 < hansihe> the schedulers do load stealing, if one scheduler has a lot of work to do, the others can take things off its queue
00:30 < rom1504> interesting. How is messaging done ? is erlang lazy or something like that ? (some kind of equivalent of js promises maybe ?)
00:30 < hansihe> it's also impossible to block schedulers, as they only work on a process for a maximum amount of "reductions" (function calls pretty much)
00:31 < hansihe> not lazy really
00:31 < hansihe> in elixir messaging is done with the "send" keyword, however you generally don't do all that much of that manually
00:31 < hansihe> not keyword actually it's just a function
00:32 < hansihe> if you build something in erlang, you generally use OTP, it implements a lot of the things you would want in a concurrent system
00:32 < rom1504> yeah but how do you "wait" for a message ?
00:32 < hansihe> receive
00:32 < hansihe> and it blocks until you get a message
00:33 < hansihe> sorry, i meant "receive", it's a function
00:33 < rom1504> I see
00:34 < hansihe> the coolest part is probably the fact that messaging is location independent, you can send a message to another box or vm just as easily as you would to  a local process
00:34 < hansihe> http://elixir-lang.org/getting-started/processes.html#send-and-receive
00:34 < hansihe> but yeah, you generally don't use send and receive much directly
00:35 < hansihe> you use behaviors, the most common is gen_server
00:35 < hansihe> short for genral server
00:35 < hansihe> general*
00:36 < hansihe> calling a gen server is pretty much like doing a function call
00:36 < hansihe> it handles all the messaging for you
00:36 < hansihe> sorry, i'm talking a lot here :P
00:36 < hansihe> it's just very cool
00:37 < hansihe> erlang is very underrated in my opinion
00:37 < rom1504> hmm, "calling a gen server is pretty much like doing a function call", do you use callbacks then ?
00:38 < rom1504> like, a function that get called when the waiting is over
00:38 < hansihe> no, not generally
00:38 < hansihe> you don't really need it
00:39 < hansihe> if you need work done in the background, you just spawn a process to do it and message you, there are abstractions for it
00:40 < rom1504> ok, I think I'd have to actually read a elixir tutorial to understand how that really work ^^
00:40 < hansihe> i would recommend it!
03:59 < Gjum> Fenhl: I just added an explanation of the serverbound Confirm Transaction packet, just to see that it's explained in at least two other places already (#Click Window and How to Write a Client#Inventory and Crafting). It still confuses people though, would it be wise to create one central explanation and link to it? (cc hansihe)
06:55 < hansihe> It's more clear now, thanks!
07:07 < Fenhl> Gjum: Protocol is the correct place for it, thanks for figuring out what it does
19:02 < hansihe> anyone know what the properties in the player list item packet are for? http://wiki.vg/Protocol#Player_List_Item
19:40 < rom1504> hansihe: skins
19:41 < rom1504> hansihe: see http://wiki.vg/Mojang_API#UUID_-.3E_Profile_.2B_Skin.2FCape, you just need to send the properties got there and skins work
19:41 < rom1504> (you can also send an empty properties array if you don't care about skins)
20:00 < hansihe> rom1504: ahh, i see
20:00 < hansihe> yeah, that makes sense, thanks!
20:00 < hansihe> i tried empty, it did work, just a bit unsure what they where for :)
20:04 < rom1504> that info should probably be added to the wiki I guess http://wiki.vg/Protocol#Player_List_Item
23:13 < Not-d54a> [flying-squid] rom1504 pushed 1 commit to master [+0/-1/±2] https://github.com/PrismarineJS/flying-squid/compare/a8f925686d35...ef50d796d609
23:13 < Not-d54a> [flying-squid] rom1504 ef50d79 - move diamond-square to its own package
--- Day changed mer. janv. 20 2016
09:36 < Fenhl> rom1504: done
18:19 <+XorBoole> does anyone know what packet causes authlib to process a UUID?
18:19 <+XorBoole> (client-side)
18:19 <+XorBoole> i.e. what packet should I send to get an authlib call
18:21 < rom1504> XorBoole: http://wiki.vg/Protocol_FAQ#What.27s_the_normal_login_sequence_for_a_client.3F
18:21 < rom1504> so I guess the answer to your question is http://wiki.vg/Protocol#Encryption_Request
18:22 <+XorBoole> rom1504 does that hit authlib though?
18:23 <+XorBoole> pretty sure encryption is not part of authlib
18:23 < rom1504> I don't know what is "authlib"
18:23 < rom1504> it certainly makes the client use the yggdrasil api
18:24 <+XorBoole> wait, I think I found it
18:24 <+XorBoole> joinServer(GameProfile profile, String authenticationToken, String serverId)
--- Log closed mer. janv. 20 19:18:03 2016
--- Log opened mer. janv. 20 19:18:13 2016
19:18 -!- Irssi: #mcdevs: Total of 145 nicks [1 ops, 0 halfops, 15 voices, 129 normal]
19:22 -!- Irssi: Join to #mcdevs was synced in 245 secs
--- Day changed jeu. janv. 21 2016
00:36 <+Thinkofname> is it me or is the client sending movement packets slower in the snapshots? (16w02a)
00:44 <+Thinkofname> looks like it sends less when standing still now
00:46 < javaprophet> Perhaps because it's running slow?
00:50 <+Amaranth> Did they finally unhook ticking from movement packets?
00:51 <+Amaranth> That'd allow them to stop sending updates with just the onGround flag
00:52 <+Thinkofname> Amaranth: the changelog suggests that, haven't looked into it
11:06 < rom1504> does the vanilla server check if place blocks are done less than 6 blocks away than the player position ? (in creative too ?)
11:52 < BrianBriu> Hi there guys. I'm trying to make a connection to a minecraft server but I am not that advanced in Java to do so. I cam here for your help, maybe you can tell me where can I find some tutorials or books about creating connections in Java. Sockets, etc. Network programming. Thank you! :)
11:54 < rom1504> BrianBriu: you can use a library, such as https://github.com/Steveice10/MCProtocolLib, https://github.com/Steveice10/MCProtocolLib/blob/master/example/org/spacehq/mc/protocol/test/MinecraftProtocolTest.java
11:55 < BrianBriu> I know :) But I really want to learn the concepts of network programming. Actually, I know network programming. The problem is that I don't know how does it work in Java. I already learned the theory, but I didn't practice at all. Please recommend me some books, tutorials :) Everything, Something where I can learn from.
11:56 < rom1504> try #java maybe
11:56 < BrianBriu> ok :) Thanks anyway for the libraries :D They're really gonna help me.
17:13 < hansihe> rom1504: i'm pretty sure the server checks in creative as well, think it's further though
17:13 < hansihe> might remember wrong
17:14 < hansihe> sorry if the reply is outdated
17:15 < rom1504> so I'm guessing the worldedit plugins in spigot disable that then, ok
17:31 < Not-b656> [SpockBot] Gjum pushed 2 commits to master [+0/-0/±4] https://github.com/SpockBotMC/SpockBot/compare/7747f01fceaa...c09dbfaf85f9
17:31 < Not-b656> [SpockBot] Gjum 7f5160d - Fix vector calculations
17:31 < Not-b656> [SpockBot] Gjum c09dbfa - Fix example
17:41 < Not-b656> [SpockBot] Gjum pushed 1 commit to master [+0/-0/±2] https://github.com/SpockBotMC/SpockBot/compare/c09dbfaf85f9...991f56981a00
17:41 < Not-b656> [SpockBot] Gjum 991f569 - yay it's flake8 again
20:56 < Not-b656> [SpockBot] Gjum pushed 1 commit to master [+0/-0/±1] https://github.com/SpockBotMC/SpockBot/compare/991f56981a00...e747ea8870a4
20:56 < Not-b656> [SpockBot] Gjum e747ea8 - Add Bat as an example to README.rst
23:48 < hansihe> and we have player spawn \o/
--- Day changed ven. janv. 22 2016
10:26 < hansihe> now block modification works, feels pretty good making progress!
10:56 < rom15043> What about 2 players movement?
11:25 < hansihe> nah, that's not working yet, only spawning for now
12:50 < rom1504> does erlang have some kind of native handling for fixed positions ?
12:51 < rom1504> (we have to store position as fixed positions (integers) in flying-squid to have precise positions, and that's a bit annoying)
12:52 < rom1504> *fixed point number (http://wiki.vg/Protocol#Fixed-point_numbers)
14:49 < hansihe> rom1504: not really
14:50 < hansihe> i just convert it to and from a float in my decoder/encoder code, that might not work out though
14:57 < hansihe> you would have to move pretty far out before you lose much precision when using a float, should probably be fine?
16:15 < rom1504> hansihe: Math.round(10*(9.95-9.9)) == 0
16:15 < rom1504> I'm not exactly sure, but we had precision problems when using floats internally in flying-squid
16:16 < rom1504> *exactly sure why
16:16 < hansihe> hmm
16:16 < rom1504> probably the same reason why mojang uses fixed point though
16:16 < rom1504> still looking for a good solution to expose "normal positions" without having this kind of problems
16:17 < rom1504> I think java kind of natively handle it
16:17 < hansihe> i hadn't really imagined i would need to do a whole lot of math like that, i was just thinking about passing the numbers around
16:17 < hansihe> thats probably foolish though
16:18 < hansihe> but yeah, if you had precision problems, then it's an issue
16:18 < rom1504> try it, if it works I'm doing it wrong, hopefully that's the case
16:18 < rom1504> (test case : start 2 clients, move around with one client, look with the other client if the first client position is correct)
16:18 < hansihe> right, yeah, i'll try it, will switch to fixed if it creates problems :)
16:18 < hansihe> yeah
16:19 <+Thinkofname> rom1504: mojang uses doubles internally, fixed point is only for the protocol.
16:21 < rom1504> hmm okay, maybe I was just doing rounding positions wrongly or something
16:36 < hansihe> rom1504: you have a separate project for minecraft data, right? how do you obtain it?
16:37 < rom1504> it's there https://github.com/PrismarineJS/minecraft-data
16:37 < rom1504> lot of explanation about it in the readme
16:38 < rom1504> that's how we get the data https://github.com/PrismarineJS/minecraft-data#extraction
16:38 < hansihe> ahhh, right
16:38 < hansihe> thanks!
16:39 < rom1504> this might be interesting if you want to use it https://github.com/PrismarineJS/minecraft-data/blob/master/doc/make-a-new-wrapper.md ;)
16:39 < hansihe> you don't use the protocol json for flying squid?
16:40 < rom1504> yes I do
16:40 < rom1504> it's used by node-minecraft-protocol
16:40 < rom1504> which in turn is used by flying-squid (and mineflayer, and other projects)
16:40 < hansihe> ah, protocol wasn't listed next to flying squid :)
16:41 < hansihe> but yeah, i think i might use this actually
16:41 < rom1504> cool :)
16:42 < rom1504> do ask if you have any question about it ;)
16:44 < rom1504> I guess it's not obvious that protocol.json is used by mineflayer and flying-squid in that readme yeah, I'll probably change it
16:48 < hansihe> i wish i knew about this before i transcribed almost the entire protocol manually :P
17:21 < hansihe> is 10 seconds a good delay between keepalive messages?
21:02 < OnlyQubes> Hello, I'm having a weird error, wondering if anybody else had this happen to them or am i doing something wrong. So when i teleport the player a big distance, it doesn't receive all the chunks it seems, im tping it here https://a.pomf.cat/wegiyz.png, but it only gets https://a.pomf.cat/jqldlo.png chunks. Any idea why its doing this ? :?
21:17 < Gjum> OnlyQubes: maybe worldgen is too slow?
21:25 < OnlyQubes> the world is generated, but the client just isn't getting the packet i think, i don't really need to send anything when the client tps to a new location? (im the client not the server)
21:29 < Gjum> OnlyQubes: should be just server-side, somebody does /tp, server sends new pos, client reflects, server sends chunks
22:49 < rom1504> OnlyQubes: do you handle (both!) chunk packets properly ?
22:53 < OnlyQubes> I handle the Single chunk and Multi chunk packets. Also now the issue seems to be fixed, not sure what changed D:
22:54 < rom1504> magic
22:54 < OnlyQubes> :D
22:55 < rom1504> be careful though, magic fixing usually breaks later :p
22:55 < OnlyQubes> yeah, still need to find out what was wrong : <
22:56 < rom1504> when you do, add an unit test for this so it doesn't break again later ;)
22:57 < OnlyQubes> Yeah ill do that. But enough work for today, byee P:
23:34 < __0x277F> I'm looking through some of the snapshot code, did they separate serverbound position packets for vehicles or am I reading this wrong?
23:36 < __0x277F> Because the wiki's prerelease specification lists a "Vehicle Move?" in the serverbound section.
23:55 < rom1504> well
23:55 < rom1504> notice the ?
23:55 < __0x277F> Mhm. :P
23:55 < rom1504> and there's no http://wiki.vg/Pre-release_protocol#Vehicle_Move.3F
23:56 < __0x277F> Since I'm pretty sure about it I am in the process of going about adding it.
23:56 < rom1504> what about Steer Vehicle ?
23:56 < rom1504> what's the difference with this packet ?
23:57 < __0x277F> It has all the same values as a position and look packet.
--- Day changed sam. janv. 23 2016
00:00 < rom1504> ah
00:00 < rom1504> wonder why they don't just use position and look
00:00 < __0x277F> Looks like packet handling is a little bit different. 
00:00 < rom1504> but then, it's mojang
00:00 < Gjum> __0x277F: what's in the "Vehicle Move?" packet code-wise?
00:00 < __0x277F> Not sure how because I'm bad at math. :P
00:01 < rom1504> Gjum: "It has all the same values as a position and look packet."
00:01 < Gjum> how many fields? which types?
00:01 < __0x277F> Excluding the 2 booleans, that is.
00:01 < __0x277F> .whois Gjum 
00:01 < __0x277F> Oops
00:01  * __0x277F hides in shame
00:01 < Gjum> ^^ np
00:01 < Gjum> I just wrote 1.8 vehicle controls for SpockBot
00:02 < rom1504> now you can throw it away for 1.9 :p
00:03 < rom1504> best would be to write generic "handle position-and-look-kind movement" generic classes/functions and to use them whenever needed without having to throw away anything
00:03 < rom1504> err I put 2 times generic, guess I'll be very generic then
00:04 < rom1504> *it
00:04 < Gjum> it sounds like the client will tell the server the vehicle's position instead of steering it and letting the server decide where it goes
00:04 < Gjum> normal movement already works like this
00:05 < __0x277F> Quick question, how does one find the packet id of something? Someone already wrote 0x10 for this new one but I want to check to make sure.
00:05  * __0x277F is new at this
00:05 < Gjum> __0x277F: they get set at runtime afaik
00:06 < Gjum> that's why they change so much between proto versions
00:06 < __0x277F> Ah.
00:06 < rom1504> yes but you can find it
00:06 < Gjum> same with entity ids I believe
00:06 < rom1504> https://github.com/PrismarineJS/minecraft-jar-extractor __0x277F 
00:06 < rom1504> that gets you the packet id <--> class name mapping
00:07 < __0x277F> Aha.
00:07 < rom1504> same one in python there https://github.com/pangeacake/minecraft-jar-extractor if you like python better
00:07 < Gjum> __0x277F: do you do any more than decompiling to look at the code?
00:07 < __0x277F> Nope. :3
00:08 < Gjum> ok. I was wondering if there is a sane way to get some name mapping going
00:08 < __0x277F> No idea.
00:09 < __0x277F> I know Spigot has some private snapshot mappings, but that's it.
00:09 < rom1504> Gjum: people write mappings for the decompiled code afaik
00:09 < rom1504> semi-manually
00:09 < rom1504> spigot yeah
00:10 < Gjum> do you know if there are any higher level tools involved? eg that compare the AST between versions and suggest names for unchanged code
00:10 < rom1504> but for us people not part of their secret organization, I'm afraid we just have to stare hard at ugly decompiled code :p
00:10 < __0x277F> So, since this serverbound vehicle move packet does, in fact, exist, does that mean that the clientbound vehicle move packet someone added to the list does also exist?
00:11 < rom1504> very possible
00:12 < rom1504> just like there's a clientbound and a serverbound Position And Look
00:12 < rom1504> Gjum: I think they have something like that, but I don't know more
00:13 < Gjum> something I sometimes use is https://bitbucket.org/cuchaz/minecraft-mappings
00:14 < Gjum> yeah if they copy player move behaviour to vehicles, that's gonna be the reflected packet to confirm/apologize to the server
00:31 < __0x277F> Okay, submitted the new packet to the prerelease specification. Maybe I'll tackle the clientbound one tomorrow.
00:38 < Gjum> __0x277F: your table has no flags field...?
00:39 < __0x277F> The packet doesn't have a flags field either.
00:39 < __0x277F> It's just coords, yaw, and pitch
00:40 < Gjum> __0x277F: but it says "Absolute or relative position, depending on Flags"
00:41 < __0x277F> Yeah, my bad on that one.
00:41 < __0x277F> I'd assume that since there are no flags available it would default to absolute.
00:41 < __0x277F> I can't be sure though.
00:43 < __0x277F> Unfortunately, Gjum, I can't fix it now as I'm gonna go out for some dinner. 
00:43 < __0x277F> If you want to give it a shot, go right ahead.
00:43 < __0x277F> Otherwise, I'll probably do it either later today or tomorrow.
00:43 < Gjum> nah, I won't steal your credit on that one ;)
00:45 < __0x277F> It's not really worthy of any credit. :P It's one of the few packets where its handling may print an error that specifies what the packet is intended to do. :P
05:42 < __0x277F> So I determined that the serverbound vehicle position packet uses absolute positioning; however, the clientbound one doesn't have a way to specify the same way player position packets do.
05:42 < __0x277F> From some filtering I think there's only one other class that meets the requirements of having 3 doubles and 2 floats.
12:58 < morfin> or crap
12:58 < morfin> http://www.ijaminecraft.com/cmd/difficulty_hell/ 
12:58 < morfin> that's one command block with command 
15:24 < hansihe> anyone know how vanilla server avoids congesting the client connection when sending chunks?
15:31 < rom1504> you got to send them  not too fast
15:31 < rom1504> also
15:31 < rom1504> compression changes everything
15:31 < rom1504> 300x
15:32 < hansihe> ahh, yeah, i'm not doing compression right now, i guess enabling that would be high priority
15:32 < rom1504> (I actually measured that, uncompressed chunks are 300x bigger than compressed ones, so that can be a few MB)
15:33 < hansihe> yeah, i can imagine
15:33 < rom1504> and well, not compressing chunks wasn't working so well in not-localhost
15:33 < hansihe> there is so much repetition
15:45 < hansihe> rom1504: what compression threshold do you use?
15:46 < hansihe> hope it's fine i ask questions by the way
15:47 < morfin> hmm
15:47 < morfin> one chunk is like few megabytes i think?
15:48 < morfin> with all blocks,lights,entities etc
15:48 < hansihe> around 3*16*16*16*4 bytes for blocks and light for a normal chunk i think
15:49 < hansihe> hmm wait
15:51 < hansihe> im sending around 60 kilobytes per chunk
15:51 < hansihe> that's without entity data though
15:51 < hansihe> maybe 4kb or something is a good threshold?
15:51 < morfin> 4kb?
15:52 < hansihe> compression threshold
15:53 < rom1504> hansihe: 256
15:53 < rom1504> that's the default vanilla threshold
15:53 < hansihe> ah
15:53 < rom1504> so I'm using the same one
15:53 < hansihe> yeah, i'll probably use that then
15:56 < rom1504> it's fine to ask questions, sure !
15:59 < morfin> so you compress every 256 bytes?
15:59 < hansihe> morfin: packets that are above 256 bytes get compressed
16:02 < morfin> ah you meant that
16:03 < morfin> 40 bytes threshold could compress too many of them and increase CPU load
17:04 < hansihe> oh yeah, compression does help a LOT
17:04 < hansihe> much faster now
17:44 < morfin> do you use gzip?
18:02 < Gjum> deflate I suppose?
18:02 < Gjum> turns out, gzip also uses deflate...
18:11 < rom15043> Minecraft protocol compression is zlib. Which is deflate yeah, almost the same as zlib I think, just slightly different headers
18:11 < rom15043> *almost the same as gzip
18:15 < hansihe> gzip is deflate with header
18:49 < morfin> hmm
18:59 < morfin> ok then
19:32 < hansihe> crouching works, but damn, the entity metadata format is something...
19:32 < __0x277F> I know, right? :P
19:35 < hansihe> Is it done by reflection or something in vanilla?
19:36 < hansihe> the way the inheritance stuff works sorta suggests it..
22:01 < Not-24d4> [mineflayer] rom1504 pushed 4 commits to master [+0/-0/±6] https://github.com/PrismarineJS/mineflayer/compare/e01d9d9e1b7f...7f7f95ea832b
22:01 < Not-24d4> [mineflayer] deathcap c47e84c - Clarify the kicked API documentation, reason is a chat message Not merely a string, see http://wiki.vg/Chat
22:01 < Not-24d4> [mineflayer] deathcap ee01393 - Listen for disconnect in login phase
22:01 < Not-24d4> [mineflayer] deathcap 7326f83 - Add loggedIn parameter to event
22:01 < Not-24d4> [mineflayer] rom1504 7f7f95e - Merge pull request #360 from deathcap/kick Kick API improvements
23:52 < hansihe> this mca file i'm looking at doesn't have a gzip header, am i missing something?
23:55 < Meeeh_> hansihe,  mcs file isn't compressed, chunks in it are compressed
--- Day changed dim. janv. 24 2016
00:20 < hansihe> well, i can't seem to find any documentation on the format at all then
00:22 < Meeeh> hansihe, what? http://minecraft.gamepedia.com/Anvil_file_format
00:23 < Gjum> more in-depth on the technical level http://wiki.vg/Region_Files
00:25 < hansihe> right, okey
00:25 < hansihe> i was mainly looking at the wiki.vg page, it had absolutely no indication that there was an header, and that it was based on mcregion
00:26 < hansihe> i probably should have read through the gamepedia one better, that's my fault
00:26 < Gjum> weird that page isnt even in the Category:Minecraft Modern
00:31 < rom1504> hansihe: that's how it's implemented in java http://pastebin.com/niWTqLvk
00:31 < rom1504> translated in python https://github.com/mcedit/mcedit2/blob/master/src/mceditlib/pc/regionfile.py
00:31 < rom1504> and then in js https://github.com/PrismarineJS/prismarine-provider-anvil/blob/master/src/region.js
00:31 < rom1504> all the same class :D
00:31 < rom1504> copy/pasting ftw
00:32 < hansihe> haha, thanks :)
00:35 < Meeeh> yeach, it is great if you want kill your server.  for (int i = 0; i < SECTOR_INTS; ++i) {
00:36 < Meeeh> this same for Output streams, they should use BufferedOutputStream too
00:41 < rom1504> yeah I did that a bit smarter in js, I think that java code is a bit unoptimized indeed
00:42 < rom1504> I'd be interested by any other open source better optimized anvil implementation example though ;)
00:43 < Gjum> > java code is a bit unoptimized
00:43 < Gjum> when is it not
00:44 < Meeeh> still better than python and most of other languages like that :P
00:46 < Meeeh> I was playing around code from wiki and from glowstone, and at the end I created own one that looks simillar and I think it works good: https://github.com/Diorite/Diorite/blob/master/diorite-core/src/main/java/org/diorite/impl/world/io/anvil/AnvilRegion.java
00:47 < Meeeh> https://github.com/Diorite/Diorite/blob/master/diorite-core/src/main/java/org/diorite/impl/world/io/anvil/AnvilRegion.java#L264-L269 I'm idiot...
00:47 < Meeeh> I created key variable to don't calculate this same stuff few times and didn't used it xD
00:48 < Gjum> > java
00:48 < Gjum> it's less about the language implementation and more how code is written in it
00:48 < hansihe> lol
00:49 < Gjum> many java projects I come across have lots of these refactoring artefacts, more than any other language
00:50 < hansihe> i'm not a very big fan of java to be honest, it just feels bad to work with
00:50 < hansihe> idk
00:51 < Meeeh> nah, I love java for syntax
00:51 < hansihe> really?
00:51  * Gjum dies
00:51 < Meeeh> I think that I will never find language that will not make my cry
00:52 < rom1504> one of the first language I used was c++, and it made me like OOP. And then some years ago I've started doing java, now I'm starting to dislike OOP :d
00:52 < Meeeh> Yes... I really like that simple standards, and it have many good sides, like every java IDE is full of refactoring options.
00:52 < Meeeh> for c++... near no refactoring options, only jetbrains is trying to create something usefull
00:53 < rom1504> yes but the real problem is
00:53 < rom1504> that you need refactoring in java
00:53 < Meeeh> python in just nightmare with all that indent.
00:53 < hansihe> i use vim for everything except java
00:53 < rom1504> you need a big tool that will generate tons of code and change tons of code, or you can't really write java
00:53 < hansihe> because in java i need an ide
00:54 < Gjum> the one single thing im missing in python is some form of typing
00:54 < Gjum> *type enforcement
00:54 < Meeeh> what is wrong with refactoring options?
00:54 < hansihe> that's on it's way in python, isn't it?
00:54 < rom1504> nothing wrong, what's wrong is that you need it Meeeh 
00:54 < Meeeh> renaming stuff, adding new param or extracting interface.
00:55 < Meeeh> yeach, it is bad that I want create interface.
00:55 < Gjum> hansihe: not really, it would prevent duck typing a lot, which is one of the core ideas behind python
00:55 < hansihe> i used to use oop for everything, i'm starting to dislike it more and more though
00:55 < Meeeh> in 1 sec instead of minute
00:55 < hansihe> hmm
00:55 < Meeeh> I don't see anything wrong with don't wasting time rom1504 
00:56 < rom1504> my point is you can do these kind of code refactor manually in little time in other languages. With java it takes too much time
00:57 < rom1504> (to do it manually)
00:57 < Meeeh> yeach, changing method name in 29472 files can be done in little time!
00:57 < Meeeh> places*
00:57 < Gjum> python is kinda upside-down, you can write perfectly well in notepad, but making your ide refactor code is hard without type enforcement/annotation and runtime dynamic changes
00:57 < rom1504> you don't have 29472 places in not-java
00:57 < Meeeh> oh, you always use your methods only once in other languages?
00:58 < rom1504> do you imagine that vanilla minecraft has one class for each and every minecraft packet ?
00:58 < Gjum> Meeeh: it's about specifying your type everywhere for example
00:58 < Meeeh> I hate languages without types :D
00:58 < rom1504> you can do types without being so verbose
00:58 < Meeeh> When I see some stuff like "auto name = ..." or "var x = 5" I want kill myself
00:58 < hansihe> the problem with java is that it's painfully oop
00:58 < Gjum> types can be as good as they can be bad
00:58 < hansihe> and without type inference
00:58 < rom1504> auto is typed Meeeh 
00:59 < Meeeh> but I don't see type
00:59 < hansihe> rust hits the sweet spot
00:59 < rom1504> but yes js has no type
00:59 < rom1504> c++ does though
00:59 < Gjum> I really like the way haskell/scala/... do it, you specify some types and it guesses the others, making it strong typing but not a pain in the ass like in java/C/...
00:59 < rom1504> nothing as strong as some other languages, but a bit better than java actually (on that point)
01:00 < Meeeh> rust don't have visible types too. (you can only add it like let : type, but this still is pain for me)
01:00 < hansihe> haskell has the best type system, i don't think it would be possible to port it to imperative languages though
01:00 < hansihe> what do you mean rust doesn't have visible types?
01:00 < Meeeh> let x = 5;
01:01 < hansihe> that's type inference
01:01 < Meeeh> and you don't see what type this is....
01:01 < Gjum> that's inference and it's good you don't have to specify it there
01:01 < hansihe> you do
01:01 < hansihe> it's obvious
01:01 < Meeeh> ok
01:01 < hansihe> adding a type there is just noise
01:01 < Meeeh> let x = someFunctionFromLibrary();
01:01 < hansihe> then you would add a type
01:01 < rom1504> Meeeh: java8 has type inference :)
01:01 < Gjum> or you wouldnt if you just pass it along
01:01 < rom1504> (some of it)
01:02 < Gjum> c++ has too, right? that auto keyword?
01:02 < rom1504> list.stream().map(a -> a+1).collect(Collectors.toList())
01:02 < Meeeh> and I just don't like this stuff :D I like to know types when I scrolling code
01:02 < rom1504> Gjum: yeah and along with lambdas
01:03 < hansihe> different tastes i guess
01:03 < Gjum> ^
01:03 < Meeeh> especially after few weeks without looking at code
01:03 < Meeeh> it just faster/easier to see what is going on
01:03 < Gjum> I just hate reading types 2-3 times where it's trivially obvious what they are
01:04 < Gjum> which java forces you to do
01:04 < hansihe> it makes editing code take up a larger amount of my time
01:04 < Gjum> haskell still allows you to say what type something is, just doesn't force you
01:04 < Meeeh> this is why people created IDE
01:04 < hansihe> i don't want to learn a new ide for every language i use though..
01:04 < Meeeh> someMethod().var <enter>
01:05 < hansihe> the way haskell does it is really cool, yeah
01:05 < Meeeh> then try to use IDEs on this same engine :P like jetbrains stuff
01:05 < rom1504> Gjum: actually it does sometimes, haskell type system is a bit too powerful to be able infer everything (unlike ocaml for example)
01:05 < rom1504> (but just sometimes)
01:05 < Gjum> I really like the idea of writing code in terms of the AST instead of plain text
01:06 < Gjum> but even intellij isnt that far
01:07 < rom1504> I agree jetbrains ide make writing code easier in java
01:07 < rom1504> but then
01:07 < Meeeh> acctually I can live with something like "auto" in c++, where I can do "Type obj = ..." or "auto obj = ..." but not like in rust
01:07 < hansihe> i use intellij for java, yeah, it's a nice ide
01:07 < Meeeh> when I always need use "let" and then I can add type.
01:07 < rom1504> you have 10k lines of code (partially generated by the ide)
01:07 < rom1504> and you're done
01:07 < rom1504> or I am done anyway :d
01:07 < hansihe> i would rather have the boilerplate generated by the compiler, not the ide :P
01:08 < Gjum> ^
01:08 < hansihe> the java hate :P
01:09 < Gjum> some concepts are bad. languages based on that concept inherit that, until they add good concepts.
01:09 < Meeeh> nah, idk, I just like that java syntax and how it looks, ofc there are java parts that I hate...
01:09 < hansihe> the syntax is the part of java that i hate the most
01:09 < Meeeh> like no primitive generics, etc
01:09 < Meeeh> or eating memory :P
01:09 < hansihe> also, nulls in java are horrific...
01:10 < Gjum>  thats how the vm works though
01:10 < Meeeh> what is bat with nulla? o.O
01:10 < Meeeh> bad xD
01:10 < hansihe> NullPointerException
01:10 < hansihe> is bad with nulls :P
01:10 < Meeeh> Gjum, but java compared to other vm stuff in 99% of test is much worse. (memory case)
01:10 < hansihe> null makes every single one of your variables into an enum
01:11 < hansihe> and you need to explicitly handle both cases
01:11 < Meeeh> hansihe, but... eem...... what then... it must do something
01:11 < Meeeh> if value is null
01:11 < rom1504> java8 has optional
01:11 < hansihe> Meeeh: simple, value can't be null
01:12 < hansihe> if you need to return nothing, make the enum explicit instead of implicit
01:12 < Meeeh> hansihe, but how? compiler can't say if something is null
01:12 < hansihe> rust does that, types need to have a value unless they are an Option
01:12 < hansihe> it can...
01:13 < Meeeh> return random.nextBoolean() ? null : object
01:13 < Meeeh> yeach, sure
01:13 < hansihe> if you simply enforce the rule that you can't assign null to a variable
01:13 < Meeeh> notNull Object e = myRandomFunction();
01:13 < hansihe> then the compiler can enforce it via static analysis, without any runtime cost
01:13 < Meeeh> and how compiler may know if it will be null or not.
01:14 < hansihe> oh, you mean in java?
01:14 < Gjum> typing!
01:14 < Meeeh> in any language... compiler may only know that variable may be null.
01:14 < Meeeh> but it can't be sure that it always be.
01:14 < hansihe> it can!
01:14 < Gjum> modulus can never return null for example, so why make it possible
01:15 < Meeeh> then we can also throw compile error for "notNull Object e = myRandomFunction();"
01:15 < Meeeh> as it can return null
01:15 < hansihe> if it enforces the rule that null cannot be assigned to a varable unless the variable is explicitly marked to be nullable
01:15 < hansihe> then the compiler can propagate that information via the type system
01:16 < hansihe> and enforce the rule in the same way it enforces that a String is not int
01:16 < Meeeh> so then it works like I said
01:16 < Meeeh> notNull Object e = myRandomFunction();
01:16 < Meeeh> will throw compile error
01:16 < Meeeh> as compiler see that it can return null
01:17 < hansihe> sure, but that would be a really bad way to do it
01:17 < Meeeh> why bad?
01:17 < hansihe> because that would be opt-in
01:18 < hansihe> it would require you to type extra stuff to mark something as not-nullable
01:18 < hansihe> it should be the other way around, as that is the base case
01:18 < Meeeh> nah, there is no "best case" here
01:18 < hansihe> base case
01:19 < Meeeh> or "base" :D, some people will want nullable as def, and some not-nullable as default.
01:19 < hansihe> as in type+null is more information then type
01:20 < hansihe> the only reason you would want nullable by default is if you want to get in trouble :P
01:21 < Meeeh> that nullable stuff is even something that I would like to see in Java
01:22 < Meeeh> nah, I wanted to make games or maybe more game server and I learned java instead of some cpp shit. Why this cpp looks so bad :D
01:23 < hansihe> but you do have to agree that having to reason about a value that is EITHER <type> or null in every single location in your code is harder then just having to reason about <type>
01:23 < Meeeh> Reading source of program, see "GSTNS" type, looking for type - no type with this name, oh it is just int as #def GSTNS! this just make my cry.
01:23 < hansihe> it's more stuff to think about :P
01:24 < hansihe> haha
01:25 < Meeeh> this will make some stuff simpler, but still... it will also add some more work in other side
01:26 < Meeeh> if I have variable that can be null, and I need pass it to non-null param of method, then I need check it, but I think it will be less work than always checking all stuff
01:26 < hansihe> it will, but the extra second you used when wrapping your type in an Option will save you hours of fixing NullPointerExceptions
01:27 < hansihe> you are thinking about this wrong
01:27 < Meeeh> ugh, what?
01:27 < Meeeh> I mean that I need check if it is null before I pass it
01:27 < hansihe> in order to have a correct program, you would need to check the variable that could be null regardless
01:28 < hansihe> calling that optional is asking for trouble
01:28 < hansihe> so you are dropping a compile time guarantee without any benefits
01:28 < kamcio96> hello, I propably found bug on wiki.vg
01:29 < Meeeh> nah, java Optionals... I don't like them :D
01:29 < kamcio96> http://wiki.vg/Entities#Living_Entity, there is LivingEntity support custom name
01:29 < kamcio96> but eg Item also support this, ss: http://scr.hu/1s1h/592zd
01:29 < Meeeh> at least in 1.9 every entity support that
01:29 < hansihe> that's because java has a type system that can have nullable values! :p
01:29 < Meeeh> idk what about 1.8
01:30 < kamcio96> im using mc 1.8
01:31 < Meeeh> then it is possible that it works for any entity from always :D test something like fireball
01:31 < hansihe> huh
01:31 < Gjum> I believe that page is updated manually, so errors like these are very possible
01:33 < hansihe> Meeeh: if you would like a taste of how java could be without nullable types, look at https://kotlinlang.org/docs/reference/null-safety.html
01:33 < hansihe> it runs on the jvm as well
01:33 < Gjum> are scala types nullable?
01:33 < hansihe> think so
01:34 < Meeeh> hansihe, yeach, this looks good, ofc "val" make me cry, but null stuff looks good
01:34 < rom1504> just use java8 Optional type, and pretend it burns when you try to write "null"
01:34 < Meeeh> yeach, and you can still pass null as optional, and you need play around .get etc
01:35 < rom1504> "play around .get" : no you shouldn't do that
01:35 < rom1504> use .map
01:35 < Meeeh> nah, I want to see really big real-time app with Optionals and with manual code, I think that JIT isn't good enough to make performance difference invsisible.
01:36 < hansihe> optionals are not a runtime feature
01:36 < Meeeh> rom1504, then you have problems that every variable needs to be final, you can't return, etc... :D
01:36 < hansihe> they are compile time in most languages
01:36 < Meeeh> hansihe, I mean java Optional class
01:37 < hansihe> yeah, in java it's runtime
01:37 < hansihe> however that's gonna get inlined immediately
01:38 < hansihe> so you are not gonna lose any performance, it's gonna be just as expensive as a null check
01:38 < Meeeh> so it may affect performance, but it is near impossible to create good benchmark for this.
01:38 < hansihe> if the code is hot the jvm will inline it
01:38 < rom1504> "every variable needs to be final" oh yes immutability :)
01:38 < rom1504> (okay not exactly, those are still references)
01:39 < hansihe> regardless, the performance impact would be minimal at worst
01:39 < rom1504> you can use .orElse at the end though
01:39 < hansihe> i think i'm done now :P
01:41 < Meeeh> nah, it just more problems than benefits, playing around that stuff, and stupid people can still pass null as optional :<
01:43 < Meeeh> nah, 1:40, time to sleep :< I still need finish my small plugin in 22 hours and I didn't even start....
01:43 < hansihe> from now on you will think of me every time you have a nullpointerexception
01:43 < hansihe> you are cursed :P
01:43 < hansihe> good night!
01:44 < Meeeh> hah :D I will never find good language for me :P ok, bye.
01:52 < kamcio96> minecarts don't support custom anem
01:52 < kamcio96> but boat do xD
01:52 < hansihe> weird
01:54 < hansihe> anyone know how metadata encoding and decoding works in the vanilla client/server?
01:54 < hansihe> some kind of runtime/reflection stuff?
01:55 < kamcio96> crystal, tnt, also support it
01:55 < kamcio96> entoty metadata?
01:55 < kamcio96> entity*
01:55 < hansihe> yeah, that's how the name is being sent
01:55 < kamcio96> http://wiki.vg/Entities#Entity_Metadata_Format hmm?
01:55 < hansihe> it's some weird dictionary format with inheritance
01:55 < hansihe> yeah
01:56 < rom1504> hansihe: I think you should just implement the general format, and add the values thingy as a second step
01:57 < rom1504> that's what we do anyway
01:57 < hansihe> i'm done with the general format
01:57 < hansihe> yeah, i will probably do the same
01:58 < hansihe> i'm just curious as to how it's done in vanilla
01:58 < rom1504> I'm currently trying to extract all the table in the entities page and put them in a decent json format. But first I have to handle colspan/rowspan fully in wiki tables, and that's being a pain ^^
01:58 < rom1504> idk how vanilla does it
01:58 < rom1504> but you're probably right
01:58 < hansihe> it seems very reflection-y
01:58 < rom1504> vanilla does everything by adding lot of classes
01:59 < hansihe> the java way :P
02:01 < hansihe> i wonder when the obfuscated class names will reach triple letters
02:02 < rom1504> already there
02:02 < rom1504> azu.java
02:03 < rom1504> 1200 classes
02:03 < hansihe> holy fuck
02:06 < kashike> 1263
02:20 <+ammar2> meh at least they don't have enough classes and methods that they need to patch the underyling the jvm to actually let thier code run https://www.facebook.com/notes/facebook-engineering/under-the-hood-dalvik-patch-for-facebook-for-android/10151345597798920/
02:24 < rom15043> Omg
02:27 < hansihe> "Manual inspection of the GSII revealed that the LinearAlloc buffer was only 4 bytes from where we expected it, so we adjusted our code to look a few bytes to each side if it failed to find the LinearAlloc buffer in the expected location."
02:48 < Gjum> __0x277F: um, yaw is rotation around the *vertical* axis, not horizontal. the head moves on the "horizontal plane". ;)
03:12 < hansihe> rom15043: in materials.json, what is the value used for?
07:53 < rom15043> hansihe: tool multipliers, they are useful to compute the digging times https://github.com/PrismarineJS/minecraft-data/issues/22#issuecomment-171660303
21:51 < hansihe> world generation is full of voodoo
21:52 < hansihe> looking at some mods, trying to figure it out, the code quality is absolute shit
21:52 < hansihe> expensive things are calculated, then never used
21:52 < hansihe> dead code everywhere
21:56 < Gjum> hansihe: do you just want to get something going better than flat that looks good on a demo, or do you want to go full vanilla-ish worldgen with caves and ores and stuff?
21:57 < hansihe> i'm looking at full vanilla level right now
21:57 < hansihe> figuring out biomes atm
21:57 < Gjum> ok cool
21:57 < Gjum> something more custom or close to vanilla?
21:57 < hansihe> gonna try to do a well documented implementation if i can
21:58 < hansihe> vanilla-ish, but i'm not gonna go for 100% equal
21:58 < hansihe> just the same ballpark i think
--- Day changed lun. janv. 25 2016
00:02 < hansihe> well i tried :P https://usercontent.irccloud-cdn.com/file/LLN5rto9/biomes.png
00:03 < rom1504> what is that oO
00:03 < rom1504> biome repartition ?
00:06 < hansihe> working on world generation
00:06 < hansihe> that's supposed to be a biome map
00:07 < hansihe> it's work in progress :P
00:16 < hansihe> yeah, i think that's a dead end
00:47 < hansihe> this looks more promising, just needs some tweaking https://usercontent.irccloud-cdn.com/file/7DVCy8w2/biomes.png
00:48 < Gjum> hansihe: what do you use for pseudorandom generation?
00:48 < hansihe> simplex noise mainly
00:48 < hansihe> in the second one i used voronoi noise as well
00:50 < hansihe> i sample the noise function twice with different seeds, once for temperature, once for humidity
00:51 < rom15043> No idea how vanilla's look like
00:51 < hansihe> then i look it up on a whittaker chart
00:52 < Gjum> rom15043: like this http://userdisk.webry.biglobe.ne.jp/025/631/39/N000/000/000/134874529503013129089.jpg
00:52 < hansihe> that's a bit old though i think
00:53 < hansihe> i think in later versions the oceans are smaller
00:53 < hansihe> https://media.mojang.com/e834c2ebb05f63b79c814904b55e8b0106a6db75/overviewMap_new.png
00:53 < hansihe> that's 1.7
00:54 < Gjum> yeah this one is more recent, having the biome variations etc http://media-minecraftforum.cursecdn.com/attachments/80/374/635582134574105219.png
00:54 < rom15043> http://www.zdnet.com/article/minecrafts-new-education-edition-written-in-c-will-outrun-the-java-version/ someone tell me they are talking about mcpe and not yet an other Minecraft version
00:54 < hansihe> yeah, that one is better as well
00:54 < hansihe> i sure as hell hope so
00:55 < Gjum> "extends win10 version"
00:57 < Gjum> "In the future, however, it seems likely that most Minecraft players will learn the new C++ version first" 
00:57 < hansihe> still need to figure out how to do oceans, i bootlegged a ocean value function thing from a mod, but it gave me this thing https://usercontent.irccloud-cdn.com/file/GRLBCA0T/biomes.png
00:57  * Gjum doesnt just "play" minecraft, he "learns" it
00:58 < Gjum> hansihe: looks more like islands
00:58 < hansihe> it does
00:59 < hansihe> but it's not very helpful either, only outputs borders
00:59 < Gjum> what about a very low-freq landmass height noise, and putting ocean where it's below a certain level
01:00 < hansihe> that's problematic when it comes to biomes though
01:00 < Gjum> well it really depends how realistic you want it to be, whittaker sounds like youre going very realistic
01:00 < hansihe> hmm
01:00 < Gjum> did you consider a general/local blur?
01:01 < hansihe> then i would have to sample multiple points
01:01 < hansihe> idk, that might be how minecraft does it
01:01 < rom15043> I want to do "generation" by using openstreetmap data, that would be awesome :)
01:02 < hansihe> oh, that would be really cool
01:02 < Gjum> generating streets and subways and stuff? :D
01:02 < rom15043> Reading it and transforming it to mc chunks would be nice
01:03 < hansihe> you could do it on the fly as well
01:03 < rom15043> Yeah
01:03 < Gjum> btw where does fs's terrain gen live?
01:04 < rom15043> It recently moved there https://github.com/PrismarineJS/diamond-square/blob/master/diamond_square.js
01:04 < Gjum> ah, thanks
01:05 < rom15043> (Because I needed it for prismarine-world out of flying-squid, for prismarine-world-voxel)
01:05 < hansihe> i thought i saw a screenshot of the terrain it generated, where was it?
01:06 < Gjum> any recent fs screenshot pretty much
01:06 < rom15043> Err voxel-prismarine-world  https://github.com/rom1504/voxel-prismarine-world
01:07 < rom15043> Stuff in http://download.rom1504.fr/minecraft hansihe
01:09 < hansihe> ah, thanks
01:09 < hansihe> yeah, that's nice flatland terrain
01:10 < rom15043> It's very basic though, it's quite possible to do better
01:12 < hansihe> my world generator attempt (emphasis on attempt) will be in rust, it would be easily usable from both js and java
01:22 < rom15043> Might be interesting. I think if I were to use it I would keep it at arm length by putting it in an other process and communicating with it over the (local) network. Using native modules directly usually ends badly for windows users in js
01:23 < rom15043> I'd be quite interested by the code of it anyway
01:25 < hansihe> Yeah that's fair
01:57 < Not-b656> [minecraft-data] rom1504 pushed 6 commits to master [+4/-2/±2] https://github.com/PrismarineJS/minecraft-data/compare/d7672f2a30f6...aacbdaffa963
01:57 < Not-b656> [minecraft-data] deathcap 2824714 - Add release name -> protocol version numbers Based on http://wiki.vg/Protocol_version_numbers pbpaste|awk '{print "\""$1"\": "$2","}' > protocolVersions.js
01:57 < Not-b656> [minecraft-data] deathcap b27ffda - Add pre-Netty protocol versions as negative These are in a different namespace, see http://wiki.vg/Protocol_version_numbers#Versions_before_the_Netty_rewrite
01:57 < Not-b656> [minecraft-data] deathcap e46ef9a - Add release name -> major version mapping Based on protocolVersions.js, but mapping to the "major" version instead. This matches the sets of versions used by minecraft-data.
01:58 < Not-b656> [minecraft-data] ... and 3 more commits.
02:01 < M4GNV5> uhhh
02:03 < M4GNV5> looks fancy
20:49 < Not-b656> [minecraft-data] rom1504 pushed 1 commit to master [+1/-0/±2] https://github.com/PrismarineJS/minecraft-data/compare/aacbdaffa963...be607b64ae73
20:49 < Not-b656> [minecraft-data] rom1504 be607b6 - add schema for protocolVersions, and add it in the readme
21:51 < Not-24d4> [mineflayer] rom1504 pushed 2 commits to master [+0/-0/±2] https://github.com/PrismarineJS/mineflayer/compare/7f7f95ea832b...ab35d25872d5
21:51 < Not-24d4> [mineflayer] Corgano 0fc7d0a - Corrected multi_block_change Corrected multi_block_change to use packet.records.length
21:51 < Not-24d4> [mineflayer] rom1504 ab35d25 - Merge pull request #364 from Corgano/patch-1 Corrected multi_block_change
22:04 < hansihe> well, now we're cooking with gas https://usercontent.irccloud-cdn.com/file/VhjRPM3s/test.png
22:15 < Gjum> hansihe: looking good, what is it used for?
22:15 < hansihe> that's a landmass map
22:16 < Gjum> so white is ocean?
22:17 < hansihe> the system i'm bootlegging is composable though, easily used for other things
22:17 < hansihe> yeah
22:17 < hansihe> i know there is too much ocean, that should be easy to fix
22:19 < Gjum> not necessarily too much, just too evenly distributed
22:19 < hansihe> hmm
22:19 < Gjum> use the power of fractal geometry to have both oceans and landmasses of any size
22:20 < hansihe> this is somewhat fractal geometry
22:20 < hansihe> i think this is the method minecraft uses
22:20 < hansihe> with different parameters of course
22:20 < Gjum> sure
22:21 < hansihe> i'll continue working on it
22:21 < rom1504> oh btw, I recently tried mcpe and looked for mines and villages. Didn't find any. mcpe generation is way behind mcpc one right ?
22:21 < rom1504> or mcpe population anyway
22:22 < rom1504> s/mines/caves/
22:22 < hansihe> huh
22:23 < rom1504> it has biomes though
22:24 < hansihe> turned the ocean knob from 10 to 2 https://usercontent.irccloud-cdn.com/file/Wz6rWxgg/test.png
22:25 < rom1504> seems reasonable
22:25 < Gjum> yaaah looks really like vanilla biomes now
22:26 < Gjum> heh, switching between them looks revealing
22:26 < hansihe> ohh, yeah, didn't notice that
22:26 < hansihe> it's the same seed, yes
--- Day changed mar. janv. 26 2016
12:09 < barneygale> hansihe, looks like old-style generation to me (lots of small seas)
12:10 < hansihe> i added another pass to add additional islands in the oceans, that might be more right
12:12 < barneygale> this is your elixir/rust implementation right?
12:12 < Not-24d4> [Charge] Wallbraker pushed 1 commit to master [+0/-0/±1] https://github.com/VoltLang/Charge/compare/5d1f890f1483...20eb73c4e015
12:12 < Not-24d4> [Charge] Wallbraker 20eb73c - charge: Cast to void*
12:12 < hansihe> well, it's for that, but i'm implementing the world generation in a separate rust crate
12:13 < hansihe> so that it's usable from other things as well
12:51 < barneygale> neat
12:52 < barneygale> i vaguely started learning rust, need to get back into it
13:01 < hansihe> it's really good once you get used to the semantics
13:01 < hansihe> in the beginning you really wrestle with the compiler, when you learn it it's very pleasant
14:01 < Fenhl> hansihe: oh, a separate crate for world gen? Would it be possible for Hematite to use it as well?
14:15 < hansihe> Fenhl: sure! you one of the devs?
14:15 < Fenhl> yes
14:15 < hansihe> what do you have for world gen right now?
14:16 < Fenhl> nothing, the server doesn't really do much yet
14:17 < Fenhl> right now we just send a single chunk column of cobble at spawn, but we don't even process block break events yet
14:19 < hansihe> right
21:10 < i74578> Hi, i have been trying to explorer the minecraft protocol. I found this : http://wiki.vg/Protocol , about the minecraft protocol. This says that e.g. the respawn packet has "Packet ID 0x07". When i e.g. use wireshark how do i see the packet ID?
21:11 < Gjum> i74578: the packets get compressed and encrypted, so it's not directly possible to see the ID. although I have heard that some use a wireshark extension for something ...
21:12 < i74578> Do u have any idea what the extension is called ?
21:12 < Gjum> (specifically this table says the packet ID is compressed: http://wiki.vg/Protocol#With_compression)
21:13 < Gjum> no but if you wait a bit, maybe someone will answer
21:14 <+Fador> I think I saw some wireshark extension years ago but it was already outdated back then =/
21:14 <+Fador> and if encryption is used, it doesn't help much anyway..
21:14 < i74578> Do u know if the packet from client to server is encrypted? or is it encrypted both ways?
21:15 < Gjum> i74578: there are also several proxies you can use to look at packets
21:15 < Gjum> yes, both ways
21:15 < Gjum> http://wiki.vg/Protocol_Encryption
21:17 < Gjum> i74578: the only proxy I have used, but it is maintained and works well: https://github.com/PrismarineJS/node-minecraft-protocol/blob/master/examples/proxy/proxy.js
21:19 < i74578> Strange, do i have to run it on a website? or what program can i use to run it?
21:19 < Gjum> you need nodejs for that
21:31 < i74578> how to i run node-minecraft-protocol from node-js, i can't find a way to navigate in nodeJS ?
21:38 < hansihe> nodejs is a command line tool
21:38 < hansihe> you do 'node <file>' to run it
21:38 < hansihe> though you probably need to install dependencies first
21:43 < i74578> yhx m8
22:08 < HoloIRCUser3> Test
--- Day changed mer. janv. 27 2016
19:19 < Not-24d4> [mineflayer] rom1504 pushed 2 commits to master [+0/-0/±2] https://github.com/PrismarineJS/mineflayer/compare/ab35d25872d5...530cc0fc376a
19:19 < Not-24d4> [mineflayer] rom1504 530cc0f - Merge pull request #366 from PrismarineJS/remove_chat_filter remove chat filter
19:19 < Not-24d4> [mineflayer] rom1504 deleted branch remove_chat_filter
--- Day changed jeu. janv. 28 2016
08:33 < Not-24d4> [mineflayer] rom1504 pushed 2 commits to master [+0/-0/±2] https://github.com/PrismarineJS/mineflayer/compare/530cc0fc376a...66273c50a387
08:33 < Not-24d4> [mineflayer] Cecer 7bc78bc - Add extra tolerance for malformed sign packets.
08:33 < Not-24d4> [mineflayer] rom1504 66273c5 - Merge pull request #367 from Cecer/patch-1 Add extra tolerance for malformed sign packets.
09:15 < Z750> zml: do you still maintain the AUR yourkit package?
18:11 < zml> Z750: yeah, version bump wanted?
18:20 < zml> version has been bumped
18:48 < Z750> zml: thanks :)
--- Day changed ven. janv. 29 2016
05:15 < Not-b656> [SpockBot] gamingrobot pushed 1 commit to master [+0/-0/±1] https://github.com/SpockBotMC/SpockBot/compare/e747ea8870a4...53175db9b7e3
05:15 < Not-b656> [SpockBot] gamingrobot 53175db - Add projects using spockbot section to readme
05:17 < Not-b656> [SpockBot] gamingrobot pushed 1 commit to master [+0/-0/±1] https://github.com/SpockBotMC/SpockBot/compare/53175db9b7e3...8d1e2f7e7f67
05:17 < Not-b656> [SpockBot] gamingrobot 8d1e2f7 - rst is hard
12:06 <+Thinkofname> Grum: in (what we call) NetworkManager, why is a concurrent queue guarded with a lock?
16:07 < OnlyQubes> Hello, i am running into some decompression error and can't found whats wrong, so maybe you can guys help me. So the problem: I get a packet with the whole packet size of 14441, but when i read a VarInt from it (to get its uncompressed size), i get the value 55. The compression is already set and the threshold of compression is 256.
16:10 < OnlyQubes> Is something special need to be done with compression with big packets? :?
16:19 < OnlyQubes> Okay the problem might be with my varint reading function, because of this maybe http://a.pomf.cat/gmgcdm.png
16:30 < rom15043> Sounds like this is an uncompressed packet
16:35 < OnlyQubes> Can they actually send uncompressed packets, when the compression packet is sent?
16:46 < rom15043> Yes
16:47 < rom15043> Hmm
16:47 < OnlyQubes> Do you know how to determine that?
16:47 < rom15043> Well you'd get a packet length of 0
16:48 < OnlyQubes> ahh yeah, but i get a lenght if 55 or something low like that
16:48 < OnlyQubes> the whole packet lenght is like 30k+ and the uncompressed lenght is ~50
16:48 < rom15043> Yeah of course if your varint decoding is wrong, stuff won't work
16:48 < nickelpro> http://wiki.vg/Protocol#With_compression
16:48 < OnlyQubes> Yeah but it gets it okay for everything else okay, just the big numbers i think
16:49 < rom15043> Well unit test it for big numbers
16:49 < rom15043> Or anyway check
16:50 < rom15043> Are you using a language where nobody implemented varint?
16:50 < OnlyQubes> im doing it in c#
16:50 < OnlyQubes> i found the varint code online
16:51 < OnlyQubes> Here it is: http://a.pomf.cat/qcbqht.png
16:51 < OnlyQubes> Im thinking its the bit/little encodian thing that is breaking it
16:53 < rom15043> Can you *not* post code as images ?
16:53 < rom15043> There are plenty paste bin
16:53 < OnlyQubes> 1 sec, ill repost it
16:54 < hansihe> << length++ * 7
16:54 < hansihe> in java at least, ++ is atomic
16:54 < OnlyQubes> http://pastebin.com/v3NvUuvy here it is in non image 
16:56 < OnlyQubes> @hansihe what do you mean by that? :?
16:57 < rom15043> OnlyQubes: I bet this one works https://github.com/SharpMC/SharpMC/blob/master/src/SharpMC.Core/Networking/BasicListener.cs#L67
16:57 < hansihe> increments the variable and then returns
16:57 < OnlyQubes> rom15043 okay ill try this one P:. 
16:57 < hansihe> they do the same thing, i'm probably just silly
16:57 < OnlyQubes> @Hansihe ahh okay
16:58 < rom15043> Anyway, you need to check if your function works or not. Let's not fix something that is not broken
17:05 < OnlyQubes> I think the problem isn't in the getVarInt function, as this one does the same thing: Packet length: 2091970, Uncompressed length: 97
17:08 < shevchik> Than you missed something else
17:08 < rom15043> OnlyQubes: are you sure you are not missing some byte or some other kind of stream desynchronisation?
17:09 < shevchik> Anyway, try reading varint like that
17:09 < shevchik> https://github.com/ProtocolSupport/ProtocolSupport/blob/master/src/protocolsupport/utils/ChannelUtils.java#L38
17:09 < OnlyQubes> It seems to be like this for big packets only, after these big bytes (chunks and stuff) it stabilises
17:10 < shevchik> Rememver that packet length prepend varint has max 3 bytes
17:10 < shevchik> If it is more than you made a mistake somewhere
17:12 < OnlyQubes> Im reading the 'Packet Length' correctly it seems, because it does say the correct lenght of the packet, the problem starts when i try to read 'Data Length' i think
17:12 < shevchik> Okay, first you deencrpyt block
17:12 < shevchik> Than you read complete packet length
17:12 < shevchik> Than you should read uncompressed length varint
17:12 < OnlyQubes> Encryption isn't enabled on this test P:
17:13 < shevchik> Offline-mode?
17:13 < OnlyQubes> yup
17:13 < shevchik> Well, than skip encryption part
17:13 < OnlyQubes> Than you read complete packet length - i do this, seems to be good
17:13 < OnlyQubes> Than you should read uncompressed length varint - random small value, is much more small than the value read before 
17:13 < shevchik> Shouldn't be like that
17:14 < shevchik> You are reading packet length wrong then
17:14 < shevchik> Probably not receiving all bytes
17:14 < shevchik> It can go up to 3 bytes
17:14 < shevchik> If you use async io
17:14 < OnlyQubes> after that i still have a ton of bytes left, like 300k or so
17:14 < shevchik> Totally reading packet wrong
17:15 < shevchik> 300k bytes is impossible length for a packet afaik
17:15 < OnlyQubes> wait ill check what ammount it says
17:16 < rom15043> shevchik: a chunk bulk packet might be that big
17:16 < OnlyQubes> oh its not 300k its 30k D:
17:16 < OnlyQubes> Now with the new varint decoder im getting some different values (https://github.com/ProtocolSupport/ProtocolSupport/blob/master/src/protocolsupport/utils/ChannelUtils.java#L38) wait ill check what those are
17:16 < shevchik> Well, thats an acceptable amout
17:17 < shevchik> Mojang varint differs from original google varint
17:17 < shevchik> And other VLQs
17:19 < OnlyQubes> ahh darn the values still seem to be wrong : <
17:20 < rom15043> What about actually trying if your varint function read things correctly?
17:20 < OnlyQubes> yeah ill go do that now P:
17:25 < OnlyQubes> It seems to work when i create the varints, tested it up to 10,000,000 and it worked all the way
17:43 < OnlyQubes> Okay figured something big out, the initial readVarInt is also bad
17:43 < OnlyQubes> i was mistaking it for being right as it creates an array with the size of it
17:43 < OnlyQubes> wops sorry, so yeah im doing the byte reading badly P:
19:25 < OnlyQubes> It seems that i cannot read big varints propely, any idea why guys? :? Do i need to do something special with big variants? *(im using this http://pastebin.com/sLJy4UAD, language is c#)
20:15 < OnlyQubes> It seems like 1 byte then it works but when it is more bytes its not good
20:17 < rom15043> OnlyQubes: does Stream automatically increase the offset when read ?
20:18 < rom15043> If not, line 22 is reading the same byte again and again
20:18 < OnlyQubes> it reads the byte and advances the position by 1 byte
20:18 < OnlyQubes> the tooltip says that and from testing i can see that it advances it P:
20:19 < rom15043> Ok
20:19 < OnlyQubes> darn this bug, killing me xD
20:19 < rom15043> What values are you testing this on?
20:21 < OnlyQubes> im logging in to a server, everything seems to be fine, but then unexpectedly it gets like a 1m value from the initial (Packet Length), it then tries to read all of those bytes, but 90% of the bytes are null.
20:22 < OnlyQubes> values seem to be normal till 115k, but the varint says its 1.8million
20:22 < OnlyQubes> 1824921 to be exact
20:27 <+Fador> are you sure you have bytes to read for the varint?
20:28 < rom15043> So you're not trying on any specific value ? You won't be able to know if you varint function is the problem unless you test it independently
20:29 < OnlyQubes> i did test it independently, generated the varint bytes myself, that seemed to work, no matter how big the value was
20:30 < rom15043> Okay, so the problem is *not* your varint function
20:30 < OnlyQubes> @Fador the wiki.vg says that i need to read a varint, it works, but not with big numbers i think
20:30 < rom15043> Look at the rest of your code
20:30 <+Fador> OnlyQubes: but what if server sends 1 byte of 3-byte varint?
20:30 < OnlyQubes> @Fador the wiki.vg says that i need to read a varint, it works, but not with big numbers i think
20:30 <+Fador> OnlyQubes: will it wait for two more bytes?
20:30 < rom15043> Test it independently with big numbers to be sure
20:31 < rom15043> Yea you need to wait for all the bytes of the packet to be there indeed
20:31 < rom15043> That's the reason why the protocol include the packet length
20:32 < OnlyQubes> Hmm, thats might be the problem
20:32 <+Fador> the problem is the packet length since you have no idea how long the first varint will be =)
20:32 < OnlyQubes> yeah thats the hard part, i guess i would need to wait for 5 bytes, thats the max size of a varint
20:33 < OnlyQubes> I can actually check if it gets a -1, witch means there are no bytes to read
20:34 < OnlyQubes> So ill check if it gets a -1, if it does that would be the problem
20:35 <+Fador> it looks like stream.Read() should return the number of bytes read..
20:36 < OnlyQubes> oh wops thats the wrong code in the pastebin
20:36 < OnlyQubes> ill update it
20:36 <+Fador> =)
20:37 < OnlyQubes> http://pastebin.com/dC1N2rs4 here it is, i read a single byte now straight from the stream
20:48 < hansihe> Fenhl: sorry for being lazy and not figuring this out myself, but what would be the easiest way to plug my world generator into hematite for testing?
20:49 < Fenhl> hansihe: not sure
20:53 < OnlyQubes> Seems like packets with lenght of about 9k aren't being read, the varint says its 36k, but its trully about 9k bytes
20:55 < Fenhl> hansihe: you would need to replace the initial chunk packets sent on player login, and if you want to see more than the initial radius you will need to implement move packet handling
20:56 < hansihe> Fenhl: can't hematite load minecraft chunks and let you render them?
20:57 < Fenhl> oh, the client? Yes
20:58 < hansihe> probably modify minecraft/region.rs, then
20:59 < hansihe> then provide it an existing player file and stuff to get up and running quickly
20:59 < hansihe> unless there is an easier way
22:01 < hansihe> think i may have fucked up the coordinate order somewhere https://usercontent.irccloud-cdn.com/file/Lka6pnkI/2016-01-29_21.58.44.png
22:59 < Fenhl> heh
--- Day changed sam. janv. 30 2016
07:47 < rom15043> :D
13:20 < morfin> hello, is that some magic
13:21 < morfin> TileEntityData:{Command:"summon FallingSand ~-1 ~2 ~13 {Riding:{Riding:{Riding:{Riding:{Riding:{Riding:{Riding:{TileEntityData:...
13:29 < rom15043> Attaching(/riding) is recursive
13:30 < rom15043> http://download.rom1504.fr/minecraft/mc-giant-pile.png
13:35 < morfin> riding can be recursive
13:35 < morfin> Oo
13:36 < morfin> is there other situations where you can have nested "blocks"?
13:47 < rom15043> Nbt is recursive
13:47 < rom15043> And json
13:47 < rom15043> So chat messages can have nested messages too
13:47 < rom15043> Not sure if there are any other nested entities, I don't think so
14:35 <+Grum> <+Thinkofname> Grum: in (what we call) NetworkManager, why is a concurrent queue guarded with a lock? <-- no idea, is it? :/
14:46 <+Thinkofname> Grum: http://hastebin.com/nadidutema.java both fields i and j
15:57 < morfin> i just saw some code finishing by }}}}}}}}}}}}}}}}}}}}}}}}}}}}}
15:58 < morfin> *command for command block
16:22 < Gjum> well chests can contain chests containing chests...
16:24 <+SinZ> 0.o
16:28 < kahrl> they can be infinitely nested, even
16:36 < rom15043> A chest can contain block entities oO ?
16:40 < hansihe> this went deeper then i thought
16:41 < hansihe> it's entities all the way down
16:52 < Gjum> rom15043: when you, in creative, control-middleckick a chest with a chest inside, you can place the item you get inside another chest and pick that one up, etc.
16:54 < Gjum> application and explanation https://www.youtube.com/watch?v=fWEeM03rnh4&t=4m30s
17:05 < rom15043> Oh okay
17:25 < morfin> chests in chest?
17:25 < morfin> holy crap
17:27 < morfin> 1728^512 items
17:28 < rom15043> How do you compute that ?
17:28 < morfin> i did not 
17:28 < morfin> that guy in video did
17:28 < rom15043> I think the only limitation is on the size of nbt
17:28 < morfin> yes as he said
17:28 < rom15043> Ok
17:29 < morfin> NBT have limit of 512