If you're interested in graduating from LÖVE, try Planimeter's Grid Engine[1], which is based on Quakeworld architecture and comes with fully client-side predicted multiplayer out of the box.[2]
In that regard, it's a lot easier than Unity 2D, which doesn't. It also has commercial support, uses pretty standard de facto formats, like Tiled, for its levels, and has been in development for several years.
It's the most starred Lua game engine on GitHub to my knowledge.[3]
Planimeter also publishes lgf[4], which is a LÖVE 11.3 drop-in replacement which provides PBR support, among other things, out of the box for those concerned with advanced workflows.
I've been using godot for my latest project and I've been fairly happy with it. In the end, the language matters less than what the toolset provides.
Planimeter looks interesting and all, but I find Lua itself to be limiting for large scale programs. It's great as an embedded scripting language.
This is much the same as love or dgame though. The api is nice, but offers less than godot and doesn't provide any kind of IDE or development tools.
When I click tutorials, I get some installation tutorials some small one or two line code about making entities, whereas with godot or unity or even love, and such by the end you've got a small basic game going.
Actually, to go on a tangent about game tutorials in general...
This:
Making an entity
class "npc_monster" ( "npc" )
function npc_monster:npc_monster()
npc.npc( self )
self:setSprite( "images/monster.png" )
end
Is not an entity as planimeter seems to suggest. It's a sprite drawn on the screen.
There is a huge difference between functional entity and that above code that every single beginner, come learn my engine now and make a game totally misrepresents. Same with player code and every other beginner tutorial. It's not the reality of any game. No entity is a sprite with nothing else.
I'm not sure what you're wanting out of an entity, but they provide more than sprites, so your idea of what Grid provides is not an accurate representation of what the engine does.[1]
I appreciate what Godot provides, but we are not interested in building IDEs, because an IDE is not a game engine. We would rather have features that contribute to games than nice editors, which everyone else already builds. Why would we compete with Tiled? Just go use Tiled. We're not competing with 2D animation software either, just go use them, export those files, and see them reload in the engine in real-time.
If Lua is good enough for for major game studios, and nginx, and other software used by the Fortune 500, it's good enough for us.
The point of Planimeter's Grid Engine isn't to provide a game engine for Lua, despite its tagline, it's to provide a game engine that you can build a game with, out of the box, with opt-in multiplayer as simple as setting `maxplayers`.
You cannot do that with Unity 2D. You can't even do it with Unreal. There is no starting up those engines within 5 minutes, launching a server, having a friend connect, and modifying entities in real-time scripting and having them see those changes.
You receive an abstraction over `:spawn()`, `:update(dt)`, and `:draw()`, and can `:getNetworkVar()` and `:setNetworkVar()` for entities, which automatically serializes and sends data and lets the engine perform engine-level, not framework-level decisions on those entities.
They tie into a save restore lifecycle, and have optional physics, that you make a single call to and it's all networked.
Even if you didn't want to do top-down or side-scroller games with this, you have all of the out of the box engine-level mechanics for building card games, strategy games, or anything else in 2D.
To my knowledge, you cannot do that, even with Unreal out-of-the-box.
I think you’re looking at the front-page examples and thinking this is what the engine does, but really it was put up to show a parallel between Grid and LOVE’s front page examples to show how one graduates from sprites, audio, and printing text to networkable entities, emitting networked spacial audio, and creating GUI elements that are composite rasterized.
The fact that they look as simple as they do is the point.
You seem to think this is an afternoon hobby project, but it’s a very old product.
We of course need to update our documentation and marketing to make that all clear, but the parent company has larger priorities and we bring in more revenue than Godot; Grid just isn’t a primary revenue stream.
I wasn't trying to personally attack your engine or anything. I've been there, I've tried many of the comparable frameworks available for games in a variety of languages. They all offer much the same thing. Drawing primitives, physics primitives, vectors, bounding boxes, simple ways to draw sprites or textures to the screen, some basic UI containers, some math functions, a built in camera, some animation helpers, a player class that wraps input, basoc network functions, utility classes, essentially, exactly the same thing most game engines and framework offer.
In the end it comes down to whatever's the easiest, most efficient to use to get a final product. It's the only thing that really matters when it comes to a tool.
If two tools offer the same things, but one tool offers the ability to do it faster, more easily and more efficiently, that's the ideal tool of choice.
No documentation whatsoever besides a sloppy "getting started", despite being at version 9. By contrast LÖVE has a very comprehensive multilanguage wiki.
Yep. Grid Engine 10 is slated to have a lot more infrastructural updates and we’re departing from some technical decisions that should make the developer experience much better.
We are held up by releasing the next version due to existing contracts we’re working on, and expanding the business.
The next version will have explicit commercial support on the website and a community version.
I'm looking forward to it. I've recently started a little game project and opted for Go and Raylib, because I didn't want to use Love2D or Defold. I'd considered grid, but it didn't seem active enough, and I figured if I was gonna settle for Raylib I may as well use go and be able to work a little quicker and with more libraries.
Such a curious thing, how we all want to love Lua so much, and yet it's so cumbersome sometimes to get work done with it. It's the beauty of it, I guess.
I was wondering, are there any games that use Grid? I would be curious to see some real-world examples using the engine, especially the multiplayer component.
Planimeter dogfoods by working on Grid Engine: Sandbox which is a sort of non-game Garry's Mod 2D sandbox which is where the development team makes features production-ready. We integrate with Steamworks for consulting purposes, but will probably not end up publishing there ourselves, and really advise clients to not do it.
We're a bit tied up with with some consulting projects at the moment, so Grid Engine 10 has been in slower development than the last few years.
We're planning on providing commercial licenses for small studios at something like a one-time $999/license with things like out-of-the-box community server support and at-cost multiplayer infrastructure, which is something like $15/yr for roughly 1,000 concurrent players at 20-tick.
I find it to be a competitive advantage that we provide community server browsers in the engine directly (think Source or further back, Gamespy/Quakespy) and no one else seems to do this? We also use the common Gamespy server browser protocol, which is also a de facto standard.
I would be curious as to why major studios don't also do the same, but the answer is that most of them want to control the servers today and not let you run your own communities anymore.
Unity allows Multiplay to basically own that, which I think is telling that they don't care about that developer experience.
Godot has no answer to any of this. You also have to roll your own multiplayer entirely.
Planimeter doesn't compete with Unity 2D mobile games. We try and stay away from that sort of image. Our software and licensing is intended to compete with desktop 2D games.
Correct, our two audiences are delivering a professional grade 2D game engine that surpasses what’s possible with Unity 2D to hobbyists with Grid Engine 9 and Grid Engine 10 Community Edition, and then delivering to small studios on Grid Engine 10 Professional Edition.
The company has been around for 11 years and was previously a Source Engine contractor. So if it seems strange that company has been doing nothing for a decade, it’s because it’s not our primary revenue stream, but up until now has been our largest open source product that I plan on commercializing.
It’s a very slow process, but one that I think we can still outpace Unity’s 2D offering on, considering that they do not deliver solutions our organization has needed for several years. And that’s their primary revenue source.
In that regard, it's a lot easier than Unity 2D, which doesn't. It also has commercial support, uses pretty standard de facto formats, like Tiled, for its levels, and has been in development for several years.
It's the most starred Lua game engine on GitHub to my knowledge.[3]
Planimeter also publishes lgf[4], which is a LÖVE 11.3 drop-in replacement which provides PBR support, among other things, out of the box for those concerned with advanced workflows.
[1]: https://www.planimeter.org/grid-sdk/
[2]: https://www.planimeter.org/grid-sdk/api/Tick_rate_and_bandwi...
[3]: https://github.com/topics/game-engine?l=lua
[4]: https://github.com/Planimeter/lgf