What is Reddit's opinion of
MonoGame?
From 3.5 billion Reddit comments
➔ MonoGame website
By popularity on Reddit, this Service is:
100 reviews of this app found across Reddit:
I am Tom Spilman of Sickhead Games. We did the port of Axiom Verge to Nintendo Switch (as well as to Vita and XB1).
The Switch is a wonderful platform to do development on... much better than the Wii-U before it. Nintendo did a fantastic job on this new platform.
The port uses MonoGame (http://www.monogame.net/) and a custom C# to C++ cross-compiler and C# runtime we wrote specifically for porting C# XNA/MonoGame titles to consoles.
WPF isn't well suited for making 2D games because with games you usually want a game loop (60FPS or 60 loops per second) and UIs usually work with events instead of loops (press button -> action).
For games you'd be better of with something like http://www.monogame.net/ or https://unity3d.com/.
But if you really want to use WPF and or keep things really limited and simple:
- Create a new WPF project in Visual Studio
- Add a
Canvascontrol to the WPF window/form. - Add <code>Image</code> controls with the gifs/images you want.
- Create a
Timerand change the positions of theImagecontrols on the canvas to move them around.
Probably nothing. While the .NET runtime is a Microsoft product, there are open source implementations of the language such as Mono which can compile C# code and deploy to just about any platform.
In college I worked on a game built with Monogame and while we were only required to support Windows, the framework supports a shitload of platforms with presumably minimal port work (pure speculation, but I suspect that most of that work would be translating controller inputs and possibly file formats).
Talking about C# for games: 1. No it's definitely not only for MS platforms (MonoGame, Unity). 2. You need to understand GC and work with it, you can write code which does not generate almost any garbage during gametime and collects everything on level unload/load. Just some games created using monogame: http://www.monogame.net/showcase/
OP has a long way to go before building a tetris clone and I don't know if recommending C is the best answer. Personally I think it's not beginner friendly - type system, pointers, lots of boilerplate. All of that stuff goes away with a more dynamic language like Ruby or Python.
If OP does want strict then maybe they should try C# with monogame
Your best bet is probably Monogame, it's the most mature and widely used C# game framework, a free software continuation of Microsoft's XNA.
But honestly, I wouldn't discard Unity just yet, it's an enormous tool which can easily give analysis paralysis, but still probably the quickest way to get the job done for any given project, even a small one - which means it's not really overkill.
MMOs are be regarded as the most difficult kind of game to make, because on top of all usual complexities of single player game development, you have to understand networking, try to prevent hackers & bots, consider the game's economy, and if there's PVP try to ensure races/classes are balanced. There's massive investment required and the market is saturated with options, but it sounds like you already know it's not an easy task!
To develop games without an engine, you will need to use 1 of 2 technologies: DirectX or OpenGL. DirectX is Microsoft (Windows) while OpenGL is cross-platform. To work with OpenGL a reasonable place to start looking would be Monogame (http://www.monogame.net/), but be warned you will not be doing anything like what you see in that video. You will be learning to code, learning how to import an image and display/position it on the screen. Then you will learn how to draw a triangle on the screen (polygon) by giving it 3 sets of co-ordinates (1 for each vertex). You will be learning concepts like vectors and object positioning, rotating, camera view frustums. It's not glamorous but it's the basics.
Game engines exist to let you skip a lot of this very basic stuff. Engines like Unity and UE will let you drag-and-drop an image in, instead of making you write code to import something. They will let you animate a rigged 3D model, without you having to painstakingly understand the in's and out's of different file formats. With a few clicks you can create a light source in your game, like a street lamp, instead of having to figure out the code for it. Both Unity and UE are free to play around with. There are an absolute tonne of tutorial videos out there for both, although I found a good place to start with Unity was a guy called BurgZerg (https://burgzergarcade.net/courses/introduction-game-development-fps/). Good luck!
Programming a RPG is a huge undertaking for a first game. The amount of interactions between items, characters, and other objects makes it pretty difficult to program. If you wish to learn both a programming language and a game engine simultaneously, I suggest starting with a few games of smaller scope (think pong, asteroids, platformers, etc.). While they may not be the most interesting, they will definitely test your programming skills and require you to think of problems in different ways.
That said, if you wish to get straight into making an RPG without the C# requirement, you can look into a tool like RPG maker. I haven't used it personally, but I have heard good things and it seems like a good way to get started making RPGs.
If you are more interested in learning C#, I would suggest the Monogame game engine, which is a C# engine based off of Microsoft's XNA. Monogame is a breeze to set up and get going, and it has some fantastic tutorials on Youtube.
An option that lies between these two is probably Unity, which will definitely get you making a game quicker than if you were to use Monogame. However, Unity does a lot of the heavy-lifting so you might not learn as much about programming. Monogame challenges you to write your own systems and structure your project accordingly, whereas Unity will do a lot of this for you.
What distro you use doesn't really matter (at the start), ubuntu, debian, fedora, openSuse...all fine. Don't spend too much time in thinking about which one...the real differences between the distros (especially for developers) show only much later. Can still switch then if you know exactly what you need.At the start, have a look at the different desktop environments and choose one of the distros that comes by default with one you like (But you can still switch desktop envrionments on a distro even if it's not the default). For development tools it makes no difference what distro you pick.
C# is supported in linux through the mono project. It's not as complete as the Microsoft implementation but useable. XNA might be available through mono-game but I have no clue how much they support and how good it is. Of course linux provides plenty of other options to make games with that are much better supported.
Generally Unity is great to begin with but can cause friction later in a complex project, as the engine is closed source and you can't make modifications to it. Alternatives would be MonoGame or Unreal Engine 4
Either that or it's cool to hate on Unity because it's very good at lowering the barrier to entry :)
Just wanted to also suggest you look into MonoGame. It's a .NET framework for making games, and is much more down to the hardware than game engines like Unity. I figure it might interest you.
This is one the few games that I'm really glad did as well. There is a bit of a story behind it too, this game wasn't made by a company, it was made entirely by a single person.
In 2011 Eric Barone got his degree in Computer Science. Then started applying for entry level-programming jobs, unfortunately nobody would hire him. I know all too well the stress of that situation because I was in it myself after graduating with a Computer Science degree. Instead for the next four years he spent 10 hours a day 7 days a week creating his first game, Stardew Valley.
I'm a hobbyist game Developer myself, so I found his story very Inspirational :) Very happy his hard work paid off.
For anyone that's interested the game was made in C# using Monogame, which is an open source version implementation of Microsoft's XNA frameowrk, it's known for it's cross platform support. One of the reasons it came for Switch is because Monogame supports Switch development.
That doesn't mean it's not viable though. For one, even though Microsoft stopped development of XNA, XNA 4.0 is still a really solid framework for game development. Then there's the fact that while XNA is canceled, MonoGame is absolutely not and pretty much picked up where XNA left off. It's not a drop-in replacement, but porting games from XNA to MonoGame is definitely not a mammoth task.
There's also FNA which serves as an actual drop-in replacement for XNA.
I'm afraid you're a wee bit behind the times on a lot of your assertions. Monogame has been supporting DX11 since 2012. There's still a bunch of active development on it, and the games coming out for it. It's even being supported by Sony to try and attract smaller developers like Past to Future Games to the PS4. In fact, there are currently games on the PS4 built in monogame. I'm sure I don't have to mention Bastion or Fez.
Please don't hate on our team. Monogame is a perfectly good piece of middleware that is allowing us to assemble a solid, fun RPG.
"Stardew Valley" was created with a game engine. One of the best called "Monogame" -> http://www.monogame.net
If you are a beginner and want to do 2d games by using an engine with an interface, look to "construct 3" (https://www.construct.net) or "game maker" (https://www.yoyogames.com/gamemaker), they can be very helpfull for you.
Generally, no - XNA isn't a very portable solution. On top of that, as already noted; XNA is officially deprecated, and you really shouldn't be making new applications in it.
If you want to stick with C#, there's various options that might be attractive. MonoGame is an implementation of XNA you could use. It's supported on the platforms you want (Bar web), and the differences with XNA are minimal.
Another option would be Unity, which is an engine that let's you script in C#. It's a genuine engine, so while it might not be as flexible as MonoGame, it'll do a lot more work for you; So you won't have to write the entire engine.
Lastly, and in the opposite direction, you could always try Xamarin - Which allows for cross-platform development in C#, it's even less of a framework than the other two, and you'll have to write your own engine in it.
As for targeting 'web' as a platform - There's significantly less options for that. You're either working in Javascript (What you'd probably refer to as HTML5), or you'll have to use a plugin. Unity has a web player, but it'll require all your users to actually install it. If 'has to run on the browser' is a requirement, you're just not going to get around Javascript.
The answer is not really.
Games written in C# that don't require Windows specific code should be easy to port. However, most of those games are written with stuff like Unity and MonoGame so they're already running on Linux and elsewhere.
http://unity3d.com/showcase/gallery
http://www.monogame.net/showcase/
Most Windows games, however, are not written in C# so this release will not affect them.
In all fairness, they have a reference. It could be a little more verbose here and there, but it's also a volunteer effort - so I can understand that they prioritize keeping the engine up to date and fixing its bugs over writing documentation.
​
So in the case I linked above, each of the SamplerStates would have a description pointing to the respective filter and address mode. I'm assuming that's just a summary tag in the source, if anyone's up for it. I am busy with work travel lately or else I'd consider it, I've been meaning to find a way to give back haha.
Well if you wann keep messing with game dev you should check out mono game which is a C# framework.
From google - MonoGame is a free C# framework used by game developers to make games for multiple platforms and other systems. It is also used to make Windows and Windows Phone games run on other systems. It supports iOS, Android, MacOS, tvOS, Linux, PlayStation 4, PlayStation Vita, Xbox One and Nintendo Switch.
I messed with mono game before and it was pretty straight forward . I liked it better then unity because I was trying to focus just on code instead of using tools(which isn’t a bad thing just the way I wann go about it) And also a lot of people recommend it over unity for 2-d game dev
I also recently started learning the ASP.net core framework for building web applications. I’m following this tutorial which is pretty easy to follow
The reason for learning this is to build a point of sales web app for my final school project.
You can hop on github and click the explore tab and just check out what others are doing, find something cool, clone it and hack away.
why do you think fna is better? You can only target the PC. With monogame you can target PC (windows, Linux, macos), XBOX one, Switch, Android, ios, ps4.
ii also recommend using the latest dev build (3.7)
I have used monogame which is the succesor to XNA in VB without issue. I have coded with over 100k 2d objects without issue.
https://www.codeproject.com/Articles/1175671/Getting-Started-with-MonoGame-using-Visual-Studio
- opentk for low level opengl https://github.com/opentk/opentk
- sdl2 by itself can work if you just need to do 2d stuff https://github.com/flibitijibibo/SDL2-CS
- monogame, more of a game framework but can simplify some things vs using sdl2 or opentk http://www.monogame.net/
If you're stricking with C#, you might want to consider MonoGame (http://www.monogame.net/) the open source successor to XNA or Unity (https://unity3d.com/), one of the most popular engines in both AAA and indie game development.
C# is a great language for games. I'm not sure why you would think otherwise. Though, truth be told, c++ is also a good alternative if you'd like to get closer to the metal.
Also, since nobody ever talks about this, you'll need assets (art, sound whatever) look at https://opengameart.org/ for stuff you can use.
I'd suggest you make sure to have a working version of MonoGame. If you do, you can find your project content file (Content.mgcb) in the solution explorer, in a folder named "Content".
From there, you can open it and add any ressource you need for your project from the pipeline tool.
If you haven't already, take some time to read MonoGame's documentation, especially this: http://www.monogame.net/documentation/?page=Using_The_Pipeline_Tool
Monogame is the open-source implementation of XNA, and is still supported. LibGDX is a good well-supported framework with a similar scope to XNA on the JVM platform. Even if you can't stand Java, Kotlin is very similar to C# in both semantics (final-by-default, extension methods) and quality of life improvements over Java (dynamic properties).
Unfortunately you can't make ARM games with Unity. I wish you could. However, there's always Monogame that can run on ARM. It's less of an engine and more of a framework, but it's still in C#. Personally I've used Unity for a few years and I'll be moving over to Monogame when I've finished up the current project I'm on. Unity just doesn't have the Linux support (for creating not playing, but playing isn't as good either.)
Good luck and feel free to link some games :)
First link is bad, you need to remove the colon, like so:
https://github.com/SiliconStudio/xenko
Also, here's their corresponding marketing site:
And MonoGame's:
Ok, I got InvPortable compiled on linux. NuGet didn't install Newtonsoft.Json because the targetFramework option in your packages.cfg doesn't include linux as a target. Expect a merge request soon to alleviate this.
Have you heard of monogame? It uses OpenTK, compiles to all the platforms you want and more, and is the successor to XNA.
Monogame is a cross platform framework that uses the XNA framework for you to build your game. I would recommend it as well since it is being updated very frequently and will be for a long time. You can also find many guides online on how to get started through just basic XNA tutorials since it uses the XNA framework. You can use those tutorials to learn the basics of XNA, or you can find some on the Monogame framework itself which are really no different.
I would also like to note XNA is nice for beginners to learn as its a very simple wrapper of the DirectX API that does most of the dirty work for you behind the scenes. But thanks to Monogame you can choose to use OpenGL as well if you wish, with the same code.
Hey,
XNA is deprecated. While it's still very much possible to create a game in it, you shouldn't start a new project in XNA.
MonoGame is a currently maintained implementation of XNA that you can use instead. Unity is wonderful as well. DirectX isn't really directly usable from C# without going into C++ as well - There's frameworks like SharpDX that let you deal with DirectX from inside C#. There's other frameworks and layers as well, of course.
The biggest difference, and a choice you need to make yourself is how much you want to do yourself. Unity is an engine, and will do a lot more work for you than MonoGame, which is a framework for you to create an engine and eventually a game in. SharpDX on the further extreme provides pretty much nothing but a graphics layer; Making an actual game in it means you'll have to start from scratch.
As a word of caution: Making a game isn't something I'd recommend doing for the sake of learning a language. Start with more basic programs first.
Microsoft is no longer supporting XNA, but Monogame, an open-source implementation of the XNA 4 framework, is still supported by its community. It's certainly less popular than Unity, but if it works for you, run with it!
This is the new documentation (here is the new pipeline software, see, you don't need XNA anymore!).
As I said before, there's an OpenGL project you can make. Why? It's easier to port to Mac, and Linux. SharpDX (a regular Windows Monogame project) is based on directX which is mostly Windows specific and a bit harder to port (as far as I'm aware).
If you need a more in-depth explanation, some better guidance or someone to shoot questions at, you can always contact me.
You do know that MonoGame is cross platform and based exactly on XNA? C# is cross platform just have to work with it more. Don't make the mistake I did and rule out C# completely.
Wow guys, lots of ideas here :) This comment is kind of in reply to the whole thread.
tbh, I don't think I will make major changes to Tolagal (e.g. classes, extra equip slots or change how AP works) because I always intended for the game to be very simple. This was for a few reasons but mainly because I didn't want to bite off more than I could chew for my first commercial game. Also because it's fun to see how far you can push a very simple combat system without making it more complex :)
I built tolagal with html5/javascript because it's really good for simple projects (and I have a lot of experience with JS from developing apps for digital TVs), but it doesn't really scale well for a large complex game. I'm building a new engine with Monogame for my next game which will be an iteration of some of the ideas in tolagal - there will be things like classes and generally more depth to the combat. I'm also building in mod support for the engine so it will be very easy to make your own flavours of the game with it.
In the content update for Tolagal the kinds of things I expect to add are:
- More talents.
- More items, things like spears that can penetrate through multiple targets. Offhand weapons like the daggers in return to tolagal. More kinds of rings (a ring that charges as you take damage is a cool idea!)
- More locations and enemies.
- Tweaking the useless talents and OP talents
- Tweaking some existing monsters
I don't think it's a good idea to change fundamental things at this point because the game is complete, and there will be people who like it for what it is and don't want it to become more complex. Fundamental changes can be saved for the next game (or your mods of it!) :)
Nice! Thanks for sharing such valuable resource with us.
XNA was cancelled, but you have an option: MonoGame! Have you ever tried it? It's basically an XNA with a great open source community behind.
You should definitely check it out, if you haven't yet. Link: http://www.monogame.net/
Look into MonoGame when you feel comfortable with C#. Monogame is the open source implementation of Microsoft's now-discontinued XNA. Bastion, Transistor, FEZ.. Many great games are made with it.
Monogame (http://www.monogame.net/) is simple and stay lightweight. C# is a modern language with a lot of good tools available. If you want a more risky/exotic approach I will personally go to rust with gfx-rs to try their new web assembly output.
Just FYI: A library is an implementation of API, they are fairly different concepts. For example, both MonoGame's main library and FNA implement an old version of the XNA API. This does not make them both XNA.
Anyhow, here's a few cross-platform libraries I've heard of:
- SDL2 - has been ported to a lot of platforms, runs on desktop and mobile easily but not as 'batteries-included' as some other libraries so you end up using extension libraries to do a lot of things
- Allegro - runs on desktop and mobile, more 'batteries-included' than SDL
You wrote:
> I really dont want to use this drag and drop technic, I want to code.
How about MonoGame?
>Is SDL2 a sort of text to visuals type thing?
no
SDL2 is just a low level library that lets you draw things to the screen, play sounds, get input, etc, all in a cross platform way.
For C# I think the best place to start is here: http://www.monogame.net/
which, uses SDL behind the scenes + a bit more, in a nice cohesive C# framework.
Software dev. Games programming background. Not up-to-date at all mind...
Engines are great. Unity for example is certainly really powerful and the deployment possibilities are superb. However it can and will cause you some comprehension difficulties very easily.
If you are a programmer already with some reasonable background in something like C++/C# or Java or whatever, then I'd work on little projects to teach you aspects of game development but from scratch. C++ and OpenGL for example. Could use Java and an OpenGL wrapper too to cut down on some of the initial complexity. After all the goal is to learn games programming, not the intricacies of graphics context creation!
Program some 2D shapes. Program a 3D shape. Add mouse/camera rotation. Add object rotation. Add keyboard inputs. Mess around with lighting. Learn what shaders are. Import a model you whacked up in Blender. Etc.
You don't need to make a whole game from scratch. That's a pretty tall order. But understanding some basic projects from start-to-finish will help you at least grasp some of the more complex topics on a conceptual level at least. If you understand the way in which games are programmed, you can start to dissect what an engine like Unity is actually doing. Otherwise you may end up with this barrier between what you can personally do in Unity and what you want to do in Unity.
PS. One of my big introductions to game projects was XNA. That's dead now. It was a simplified C#/DirectX framework specifically built for Indie devs and the Xbox 360 Arcade. A modern version of this could well be MonoGame, which looks popular and supported and even open-source. I may even have to look into that more myself.
C# is a great language, it's free (Community Edition of Visual Studio), and when paired with a multimedia library/engine of some kind (like MonoGame, Unreal, or Unity) can easily create great games.
It does have a learning curve however so to develop your skills you will need to do some learning.
For an introduction to programming with C# (this is a good book): C# Player's Guide
And once you're a competent programmer with that you can build on that base for free with something like: MonoGame
C#, MonoGame, and Visual Studio can all be had for free. The book costs money.
You will be much better served in the long run by learning a real programming language (like C#) than you will be by learning the interface of a domain-limited game creation program.
I am Tom Spilman of Sickhead Games. We did the port of Axiom Verge to Nintendo Switch (as well as to Vita and XB1).
The Switch is a wonderful platform to do development on... much better than the Wii-U before it. Nintendo did a fantastic job on this new platform.
The port uses MonoGame (http://www.monogame.net/) and a custom C# to C++ cross-compiler and C# runtime we wrote specifically for porting C# XNA/MonoGame titles to consoles.
The download page has the installer for macOS.
I believe it works with Visual Studio for Mac but if not it does work with MonoDevelop. Make sure you have those installed before trying to install MonoGame.
http://www.monogame.net/documentation/?page=main
https://msdn.microsoft.com/en-us/library/bb203940.aspx
Should be able to find most things in at least one of these two. If not, there's usually someone online here that can help, also the monogame forums.
why the vote down ? because I mentioned xna ?
you do realize monogame is just a reimplementation of xna ?
http://www.monogame.net/about/ "MonoGame is an Open Source implementation of the Microsoft XNA 4 Framework."
and the gamefromscratch tutorials are excellent
If you want to make a game using C# without Unity, check out Monogame.
It's a graphics framework you can use to try and write a game in C#, which I find to be a very different experience than using a big editor like Unity.
dust an elysian tail was made with and when XNA was a thing (more accurately when it died). If you wanted that, you'd go with Monogame, which is basically an XNA successor.
Skullgirls uses Z-Engine, never heard of it, you'd haft to look it up yourself and get an impression.
you can check out the Engine FAQ to dig around and look for engines that fit your needs. I'd suggest working with a framework, since what you need is specific.
When it comes to choosing an engine, that decision is left for you. Because you know you game batter than we do,m and you know what it is going to require. Asking this sub will result in "You should use Unity/UE4/GameMaker/[Enter popular Engine Here]." or "You should use the engine I use, because I use it and like it!" or "Just pick and engine, it'll do most of what you want it to do."
Hope you find what you need!
I think that you should look into monogame
it has taken over from XNA and is a fully managed library that works great in vb.
http://community.monogame.net/t/monogame-template-vbnet-for-windows-desktop-directx/1213
you will have to pull a lot of information from teh C# examples but you can use a code converter like the telerik one to get it from c# to vb.net
I think this confusion is still being played out as Unity, Microsoft and MonoGame try and figure out where they all belong together in our current world.
That said, MonoGame is still your best bet unless you start coding in C++.
http://www.monogame.net/news/ <---they call out Windows 10 Universal apps.
(edit: also check out Unity. It's great)
Nope! The latest version includes a content pipeline (no XNA required)! Here's a link to the docs on how to use the pipeline tool. Don't forget to set the content type to "Copy" when you add a piece of content to your project.
There's nothing wrong with writing a game in WPF, it's still an application after all, and it is a showcase of your knowledge.
But if you are looking for something to write games with, which isn't Unity, then check out MonoGame.
If you're looking to introduce a number of graphics or sprites into your game, I'd strongly suggest using Monogame if you're not already.
If you're using WinForms or WPF and don't want to rewrite for Monogame, use PictureBox and Image controls respectively to place images in your application.
I would recommend XNA/Monogame with C#. It's fairly easy to started with and you'll learn the concepts of game development that you will be able to use with any language or library in the future.
Just take a look at: http://www.monogame.net/
What do you want to make, and what do you already know? http://www.unity3d.com is great for more complex 3D games, but a little overkill for first programs. http://www.monogame.net is pretty good for 2D games but it's kind of expensive if you want to make games with more than 32KB of compiled code on Android and iOS (it's always free on Windows, Mac, Linux, and Windows Phone). Both of those use C#. If you're already comfortable in a different language, like C++, you may want to use a framework with C++ support. If you don't know how to program at all, I suggest you do some general tutorials before you start looking at making games.
Not necessarily. Someone previously mentioned the Monogame framework which is great for porting games that utilize .NET to other platforms. There are some other cross-platform frameworks too but I'm not to familiar with .NET.
You can use vscode, dotnet core, and the monogame framework to make pretty nice games. Maybe check it out.
http://www.monogame.net/ https://github.com/andrew-r-king/monogame-vscode-boilerplate https://github.com/kiootic/MonoGame-core-template
With XNA being discontinued a few years ago, OP should take a look at these replacements / reimplementations:
Most XNA documentation will apply. Leave out the content pipeline chapters.
If you want to learn C#, then go ahead. I don't see you regretting that choice.
Check out
... for XNA replacements that are still being maintained. There are various more frameworks and engines that let you use C# if you are so inclined.
Maybe you could try out Sadconsole (based on MonoGame).
> SadConsole is an MonoGame 3.7-based game library that provides an engine to emulate old-school console and command prompt style graphics. One or more textures are used to represent the standard ascii character set. SadConsole allows you to create console instances which can be managed independently of each other. A console is made up of individual cells which can have a foreground, background, character, and a special effect applied to it.
>
> SadConsole can be used on Windows, Linux, and MacOS.
I am not affiliated. MIT license: https://github.com/SadConsole/SadConsole/blob/master/LICENSE.md Subreddit: /r/sadconsole/
Recent thread about terminal game tech:
- /r/gamedev/comments/e92alz/ever_developed_a_terminal_game_any_pointers_where/
There's lots of good answers about how to dive in to graphics APIs, and I want to suggest an alternative that still lets him make stuff that's clearly a game: MonoGame (which is based on Microsoft's canceled XNA framework).
It's a great, programmer-focused API for making games in C#. I used it before working on games professionally, and it was a really helpful level of abstraction that helped get me ready to do this full-time. It also handles (but doesn't hide) some of the complicated work of game dev like asset management, which is the sort of stuff that could be exciting or joy-killing, depending entirely on your son's reaction.
Maybe you could try out Sadconsole (based on MonoGame).
> SadConsole is an MonoGame 3.7-based game library that provides an engine to emulate old-school console and command prompt style graphics. One or more textures are used to represent the standard ascii character set. SadConsole allows you to create console instances which can be managed independently of each other. A console is made up of individual cells which can have a foreground, background, character, and a special effect applied to it.
>
> SadConsole can be used on Windows, Linux, and MacOS.
I am not affiliated. MIT license: https://github.com/SadConsole/SadConsole/blob/master/LICENSE.md Subreddit: /r/sadconsole/
Content.Load isn't supported any more, the proper method is Texture2D.FromFile or Texture2D.FromStream.
More details can be found here http://www.monogame.net/documentation/?page=M_Microsoft_Xna_Framework_Graphics_Texture2D_FromFile
​
I've never tried it with sound effects, but I assume they work the same way.
Why not use Monogame?
- Useful MonoGame Related Links U-MG-RL, found on Monogame community forums
For performance reasons, "pixels based" stuff is almost always faked anyway; meaning, a sprite is still a texture on 2 triangles, not simply pixels drawn directly to the screen. You just render everything to something like a 640x360 texture, then display that fullscreen.
If you want to work with something lower level than a complete engine, some good cross-platform options are Monogame with C#, Heaps.io with Haxe, or SDL with C or C++.
Don't know what you didn't liked in OpenTK documentation, it has a very newb-friendly explanation how to implement a camera. If you don't understand it then it's because you skipped all previous tutorials. Each successive article heavily relies on a previous so I recommend starting from chapter 1.0 and not skipping forward.
If it's still too much then get something simpler like MonoGame, it is basically a wrapper around OpenTK/SharpDX depending on which platform you want to use. It is one step higher in abstractions it provides an has more practical documentation and more active community. Basically, it's a continuation of Microsoft's XNA so if you can't find something for MonoGame then seek XNA 4.0 tutorials, they still work.
Receive view and projection matrices for eyes, render frame, send two textures for left and right eye back. Now if you ask how to send textures here's a trick: OpenVR requires either DirectX or OpenGL texture pointer and MonoGame hides it under RenderTarget2D object, so you need to use reflection to access pointers, here's an example: link. Also the whole project is educational for a purpose of making VR game.
This: http://www.monogame.net/ is both the replacement to XNA and probably what you want. The term you want is "game framework" vs a game engine, which is more heavy-duty and feature-complete.
You could try
- http://sadconsole.com/
- /r/sadconsole
> SadConsole is an MonoGame 3.7-based game library that provides an engine to emulate old-school console and command prompt style graphics. One or more textures are used to represent the standard ascii character set. SadConsole allows you to create console instances which can be managed independently of each other. A console is made up of individual cells which can have a foreground, background, character, and a special effect applied to it.
I am not affiliated. MIT license
Nah the old one is better tbh. Has the M from Mono. The second one is cool but if you really see it's about monogame
So definitely works better
MonoGame is pretty dope. It's based on Microsoft's XNA framework, which is either awesome or the worst thing ever depending on who you speak to lol. It has a great content pipeline system that makes it really simple to knock up prototypes (at least in comparison to rolling it yourself, you'll probably still be less efficient than a generalised engine until you have tools made).
Otter2D is supposed to be pretty cool too, but the limitation is in the name.
If you hate yourself you can check out SDL2-CS
If you tire of rolling your own engine, Unity and Godot both use C# for their fiddly bits, with Unity being very mature, but Godot being very easy to learn.
What does this mean?
> Lua provides more flexibility
And what does this really mean?
> More powerful
Please don't get me wrong, no offense meant. English as a 2nd language here. I might sound hostile, but I don't want to sound hostile. But I want to assure you that I've heard people say that "XYZ" is powerful just too many times. Everything is powerful. EVERYTHING is powerful. Everything is so powerful, nothing really matters anymore.
> Gamemaker is so powerful!
> C++ is so powerful!
> Godot Engine is so powerful!
> Visual Basic is so powerful!
TL;DR You should use Heaps. Or maybe MonoGame. Or how about this little gem called Raylib? Bindings for dozens of languages available.
C# is a pretty awesome language that's getting more cross-platform support.
There are usually .NET bindings for most libraries. There are SDL2 bindings for .NET that work with .NET Core, enabling cross platform development. There's also MonoGame: http://www.monogame.net/ Duality: https://www.duality2d.net/ SFML: https://www.sfml-dev.org/index.php
and of course Unity and CryEngine support C#, but those are higher level than needed for an emulator.
Ok you should reaaaa..... wait...
You said... F#? Come to the dark side!
I wasn't aware there was version 3.4 of XNA, but I think there was a version 4.0 after the 3.x versions. But I digress.
Have you tried...
Simply put, MonoGame is a cross-platform framework that does the heavy lifting for you, without providing you with an actual engine. You could see it as a high-level API for things such as graphics, input, etc.
Just for the record, knowing you're not using .NET - but for anyone who uses .NET:
I've successfully noticed that you can compile a .NET .exe file using Mono (commandline) even on a Raspberry Pi Zero; That .exe ran then successfully ran on a Windows 10 machine with .NET, so not even a Windows installation of Mono was necessary. Both the C# and the F# compilers worked.
Sadly I found no use case for this revolutionary revelation.
By the way, for anyone reading this, please don't confuse Mono with MonoGame. No, I haven't tried compiling a MonoGame sample because, again, I found no use case.
Why Remote Desktop? Can you run a browser without Remote Desktop? Or is it possible to run a browser via your remote desktop without problems?
Here's a weird option:
- Bridge.net + MonoGame, here's an example with links to source code and explanations: http://www.monogame.net/webdemo/ - maybe you could give MonoGame another chance?
- Bridge.net plus Phaser: https://phaser.io/news/2017/11/retyped-phaser-bridge
- Pixi JS: https://retyped.com/?q=pixi#search
Phaser.io and Pixi JS are JavaScript frameworks. Phaser is excessively targeted at games, Pixi JS describes itself as:
> The HTML5 Creation Engine
> Create beautiful digital content with the fastest, most flexible 2D WebGL renderer.
I'm no expert on Monogame, or coding in general, but I'm not sure what your "origin: origin" part of your code is doing, it's not something I've seen in any tutorials I've looked through. My guess is it's something with that causing the warning.
The simplest way I know how to do draw is spriteBatch.Draw(Texture2D texture, Vector2 position, Color)
"Color" is the tint on the sprite, if you don't want a tint, you use "Color.White".
Here's a useful tutorial that I used: http://rbwhitaker.wikidot.com/monogame-2d-tutorials
You can also look through the various overloads of the Spritebatch.Draw method on the Monogame website:
http://www.monogame.net/documentation/?page=T_Microsoft_Xna_Framework_Graphics_SpriteBatch
Hope this helps.
What area of software development most interests you? Mobile apps, desktop games, web development...?
Back when I was starting out, I flew by this list of tutorials which were great primer for C# and .NET framework:
https://www.homeandlearn.co.uk/csharp/csharp.html
I then transitioned to XNA framework. That's obsolete today but I recommend MonoGame (open source implementation of the same thing), great for learning the core fundamentals of what makes an average game tick:
http://www.monogame.net/
Tutorials for that are everywhere, no specific one I can recommend.
I remember RBWhitaker's Wiki being a great starting point for learning HLSL Shaders: http://rbwhitaker.wikidot.com/intro-to-shaders It uses MonoGame and foundation to get things running and it's tons of fun.
After that it was Unity C# for me, and I'm currently scraping time to learn Unreal Engine C++, but that's ways off. Anyway, if you need any help, feel free to shoot me a message (however reddit calls it... Personal Message? Direct Message?)
Just solved this for myself this morning. On http://www.monogame.net/downloads/, scroll down on to the development build for mac and install that.
I ended up doing a few different things, but this one made it work finally. If it doesn't help you, I can retrace my steps and see if I can't come up with something.
Works for me. Try clearing your browser's cache.
Here's a direct download link for 3.6 for Visual Studio:
http://www.monogame.net/releases/v3.6/MonoGameSetup.exe
and MacOS 3.6:
http://www.monogame.net/releases/v3.6/MonoGame.pkg
If none of that works, just download it from the git repo:
Half way down this page are the development builds
VS 2017 is brilliant but there's always a problem with third party integration. 2015 fundamentally changed the way that extensions worked which meant a load of them just disappeared :/
I spent quite awhile comparing engines. I wanted to choose an engine that had great community support, was free, let me use C#, and gave me reasonable control over how I structured stuff.
In the end it came down to Unity and Monogame. For a 2D project, Monogame seemed to make more sense, especially since at the time, I could not use the latest version of .NET on Unity. Unity also was quite opinionated on how it would force me to structure my game world.
I did some rapid prototyping in both and ultimately settled on Monogame.
During development we did run into a few issues and the monogame team was very responsive and gave us development builds with fixes to try out before they rolled them out to the rest of the community. Top notch team.
Monogame (http://www.monogame.net/) is also an option, if you want less of an engine and more of a basic framework. It might be a better choice if you'd like to go a little more in-depth (compared to using ready engines, that is). Coding in C# lets you focus more on the game than the oddities of the language, so that's also a plus.
Try to teach them how to implement simple 2D games using something like MonoGame http://www.monogame.net/ . There is also a course about learning C# through MonoGame on Coursera https://www.coursera.org/learn/game-programming that could give you some suggestions on how to approach the subject.
It was made using Monogame. That would probably be the best, but it may be kind of difficult if you don't really know how to program. It's a free framework.
If you don't really know how to program you may be better off using Game Maker Studio. It could do this type of game easily enough.
Ok, language wars aside here is my advice.
First: if all you care about is a game then it doesn't matter. It just needs to be fun. The only thing that could sway you is how may systems can you deploy to:
https://libgdx.badlogicgames.com/features.html
I think monogame wins there.
Now, here is my general programming career advice. Oracle bought Java and doesn't seem to love it much. I don't think there is a great future in it. C++ is cross platform but steeper learning curve. However, under Nadella .net has a bright future.
I could go on about the versatility of c# and accessing C/C++ libraries but I hate long reddit comments :)
the monogame site says "We currently support iOS, Android, MacOS, Linux, all Windows platforms, PS4, PSVita, Xbox One, and Switch with more platforms on the way."
in the redditthread he says he'd like to make a 3DS port, but monogame doesn't support it, but Unity seems to
I don't know what other consoles he's having problems with
he streams his development every Tuesday and he always answers questions so maybe you could ask him what problems he having
For Monogame, I would suggest looking at some tutorial sites instead. the tutorials section is a good place to start, as is RB Whitaker's tutorials
er, could you elaborate a bit on that response? even just clarifying "yes it does" or "yes you are correct it does not"
I'd look it up myself, only trying to just now reminded me of why I mostly stopped paying attention to MonoGame, the lack of documentation: http://www.monogame.net/documentation/?page=Getting_Started
Well to start off, assuming you're using a Windows PC, get Microsoft Visual Studio Express for free here, and then once that's done and installed, go to the Monogame website and download the visual studio version.
All the MonoGame docs are here, including tutorials on how to get started and stuff. Good luck!
Also if you have questions you can always ask the community at r/monogame
If you're keen to leverage your previous XNA experience, you could try Monogame.
My understanding is that it's an attempt at a complete, open-source re-implementation of XNA
Check the internal exception, it will contain more details on what went wrong. Most likely the asset can't be found which means it's not copied into your bin folder. Check out the docs or the forum for more information.
Docs: http://www.monogame.net/documentation/?page=Using_The_Pipeline_Tool
Fair enough. I agree that the setup process could be better, though that pain is shared by Monogame as well. Last time I checked their templates didn't work at all on Mac, and the Android story is bad too (not their fault, Android's fault really). As for Gradle: you don't need to manage anything, you can essentially ignore the entire build and only use it for importing. Plus, everything is quite heavily documented.
I don't get the "you need to be an expert in IDE X" argument. Don't you need to know your way around VS/Xamarin as well? We have separate walk throughs for every IDE and the CLI if you want that. They cover everything, and are barely longer than 2 printed pages. We even have videos for each IDE that aren't longer than 5 minutes that show you how to use any IDE with our shizzle. Not sure how that can be made any simpler.
API wise I'd definitely be interested in feedback. Community wise no OSS engine comes close to Unity obviously, but I believe libGDX's story is quite a bit better than Monogame's on that front.
Regarding the documentation, Monogame essentially relies on the old XNA docs for the APIs. Their own docs which should cover platform specifics, setup etc. are essentially non-existant. See http://www.monogame.net/documentation/?page=main. I believe we are doing quite a bit better there with our docs https://github.com/libgdx/libgdx/wiki
Ultimately I agree that Unity will be simpler for newcomers.
It depends, but the short answer is that neither of those are really great options.
XNA was discontinued years ago. If your objective is just to learn game programming, it's not a bad target, as the general ideas will be transferable but your knowledge of the library won't be (necessarily). If you're interested in a modern XNA, there's Monogame
Windows Forms isn't really made for games. That said, if you're making a game that's mostly buttons / interface and not a lot of fast-paced images, and you want to learn Windows Forms anyway, it's not a bad route (I don't know enough about Forms beyond this to say how modern it is, however).
It basically comes down to what you're looking to get out of this:
Learning / Playing Around Either of the above will work, pick whichever one is closer to what you want to learn (XNA for games, Forms for ordinary windows apps).
Make a Game You're likely better off using a pre-existing engine if your goal is to make a full-fledged game. If your experience is in C#, Unity is a good choice, if your experience is C++ or nothing then try Unreal.
Make your own game engine / join the industry This is the longest and hardest route. You will need to know C++. You will need to learn DirectX and/or OpenGL. You'll probably need to learn shading languages.
These aren't exclusive options; I've done my share of low-level engine hacking, XNA back when XNA was new, and I'm playing with Unity to make VR games now. I'd start with whichever of those is the most important to you, learning or making a game (and I'd advise doing at least a little of one or both of those before diving in).
Also /r/gamedev is a good subreddit for picking up all this sort of thing, they have a reasonably good sidebar full of resources.