Jump to content
  • Advertisement


  • Content Count

  • Joined

  • Last visited

  • Days Won


frob last won the day on September 10

frob had the most liked content!

Community Reputation

45517 Excellent

About frob

  • Rank
    Moderator - Mobile & Console Development

Personal Information

Recent Profile Visitors

The recent visitors block is disabled and is not being shown to other users.

  1. frob

    FXML and CSS in JavaFX

    They are independent. FXML is a markup language used for JavaFX. Since you are trying to build a GUI in JavaFX you'll probably to use it. FXML describes what UI elements like labels and text boxes should appear on the screen, and where they belong. FXML allow you to change the layout without recompiling the code. You can design the application to manually place the elements in code if you prefer. You can define your dialog boxes and window layouts by hand although it is much faster using IDEs that have tools to let you position your UI elements easily using FXML files. CSS is a style tool for web pages. It is often abused in corporate environments because marketers and artists refuse to accept that CSS is often overridden by users and script blockers, and can be modified or completely ignored by web browsers and user. JavaFX allows you to include styles from CSS so that your application can have a visual style that matches your web pages. Mostly it was added to make marketers happy for consistent branding, and they are a thorn in the side of developers forced to use them.
  2. Is there a question in there that I couldn't find? Good luck on your idea.
  3. So much this. If you are making one version of your game for sharing with the world, and you're only on the PC you don't need to do anything fancy at all. Transmit the four bytes and be done with it. If you are sharing on multiple platforms that are using the x86 chipset (PC, PS4, XBOne) you can do the same. You will need to make certain your protocol works on all the devices, but can transmit the four bytes as-is for integers and floats and they are directly usable. What you do with the data may have other issues and trying to build a deterministic game is a massive undertaking, but that's not the topic. Serialization to the same chipset is not an issue. When you change chips it is an issue. Last generation of game consoles you would not have been able to share between PC and the consoles because they had different in-memory formats (in addition to the first-party companies rejecting the concept of cross-platform play). Tools and data typically cross platform boundaries, so those needed to account for the different ordering between the PC where the data was built and the console where the data was consumed.
  4. frob

    I didnt know who to ask.

    There have been a few games like that. One that has had a few variants in history is a tank. One player controls the vehicle movement, another player controls the weaponry. Heroes Of The Storm (HOTS) currently has a two-headed ogre. One half of the ogre is melee, the other half is mage. When they can work together the ogre is powerful, but most of the time unless the two players have practiced together, the character appears somewhat inept and comical in game.
  5. There are flags you can check to see about the card. The NPOT (non power of two) extension has been in all the cards since about 2005, and has been in the core since OpenGL 2.0 (2004). That doesn't answer about what happens if you try to load large images or images that aren't supported by SDL. Anything over 16384 across is unlikely to be supported. While they make pretty images that can be zoomed, they aren't a natural fit for graphics hardware.
  6. It looks fine with a once-over. This is the type of code that every game builds, and it is simple enough that it is rarely reused. That is the only complaint about it. It re-invents the wheel, and it is an easy wheel to re-create and customize when needed. A more typical implementation is to use an unordered_map instead of a map, since the hash table of unordered_map is faster to look up than a map when the table gets big.
  7. frob

    Seeking young apprentice

    I think this conversation finished being productive a while back.
  8. I worked on those back in the mid-90's. The little blue boxes were relatively zippy with a lot of fast cache relative to the era. Irix has it's quirks, but it more or less the same as other equipment of the era. The C++ standard library of today was initially based off SGI's template library, which became the "standard template library" that led to the nickname STL. There are some minor differences but if it exists in the libraries it will generally match the modern behavior. Without the disks, though, you may be in trouble. SGI's bankruptcy a decade ago means you may have a hard time finding the resources online. They're about the same timeframe as Intel's 486. Computers have come a LONG way since then. If your goal is to learn C++, there are free tools online like this to where you don't even need to install a compiler on your machine.
  9. It needs to be enabled, it is not contradictory. When debugging starts the file needs to exactly match. When it is paused in the debugger the system double-checks that it matches. Only after it has verified that they match, it allows you to make modifications while stopped in the debugger. Those changes are patched in to the running executable.
  10. frob


    I think this is a community without an end goal. The end is that we are a community. A Q&A site the end goal is to answer all questions. A tutorial site the goal is to provide good tutorials on every subject. An educational site covers all the topics from beginner to mastery, then is complete. We aren't any of those. We are a discussion board. We discuss issues people are seeing in code. We discuss issues people are seeing in society. We discuss issues in the industry. We discuss code errors. We discuss game ideas. We discuss job hunting and career growth. As a community for discussion, we won't reach a point where we've discussed all the the things since new topics are open for discussion. New people will come in and want to discuss old topics. Those don't get closed to a link to the old discussion as happens in Q&A sites, we have the discussion over again with new faces and new resources. I don't see this as a loose end, I see it as open-ended by design.
  11. Exactly how work gets divided depends on the team. Different people have different styles. Usually the team leads and project managers break down large concepts into individual tasks. Those tasks are distributed to people by lists, or during meetings, or with organizational software, or by email, or by slips of paper, or by talking face-to-face, or by various other means. Usually multiple methods are used. The task might be assigned in software, AND there are meetings discussing it, AND there are individual discussions. Another team might use a physical task board, AND slips of paper, AND in-person meetings. As for code, there is generally one large code repository that works like a library. Files are checked out, edited by individuals, then checked back in. Tools have more complex options to limit the damage caused by mistakes. Often each person works with their own personal copy of the library, makes their changes to their personal copy, then merges the files back in to the main. The exact workflow also varies by team.
  12. If you are using Unreal, they do some compilation naughtiness that breaks edit and continue. Unless you have some post-processing going on (or build interference like Unreal does) your binaries should be the same ones that Visual Studio has built, so they should be exactly the same as the ones the source was compiled with. There are several options that need to be set to ensure the correct debugging information is present as well as space for the system to inject the re-compiled code, but once those are set the system is a great time-saver. The setting is required because the file starts out matching, you pause with a breakpoint then modify the file. The difference is compiled and injected into the executable through the dark arts. Without the setting the compiler won't know which code you have modified during the breakpoint and which was modified at other times.
  13. How synchronized do you need this to be? Most interactive games do not have synchronized processing. The game server behaves as though it lives some time in the future, the game clients behave as though they live some time in the past, and each client is at some time that is independent from the rest. When games require a time, often a game will call the start of the round a specific time (e.g. time 0) and all the events over the course of the game are based on time relative to that timer. If the server gets a timestamp it doesn't think is right (either too far in the past or in the future), it will discard the message. Even if your game has a great ping time, out in the real world you are unlikely to consistently be less than a frame, or about 16ms. Even if you could send the messages in 15ms, you'd only have 1ms left for the game to do any work and hit 60 fps, the most common monitor refresh rate. Round trip times of 50ms, 80ms, even 100ms are commonplace. A 100 ms ping means waiting over six graphics frames before getting a response from a message. If the games must be synchronized every frame you are unlikely to enjoy interactive framerates. That works well for games that have low framerates, or games that simulate the game at a much slower pace. Many of the early RTS games updated their game simulations at 4x per second (250ms between updates) so they had time to synchronize the networking stuff. If you are building a game that doesn't require high communications speeds synchronized simulations can be accomplished by being extremely careful about what is sent, compressing data, the signal-to-noise ratio of what is sent versus the overhead of internet packets, and timing within the program itself. If you do that, be prepared to add all kinds of animations and interpolation between frames to keep the player engaged. Or write a game like chess or go where simulation steps can take a very long time.
  14. Generally lots of layers is the best design solution here, plus careful engineering that gives a good mix of performance and usability. Think in terms of functionality and what systems own various functionality. Each system should know about the things it contains and the things it uses. Systems might need to know about some of their peers. Beyond that, systems generally shouldn't interact. Consider how UI forms are put together for an example. There is an object called a button, an object called a label, an object called a list box, an object called a dropdown box, and so on. These objects can exist independent of the rest. Then you can make a panel as a container, and give it some buttons and some dropdowns. You can write some logic to the panel that manipulates the buttons and dropdowns, and exposes an interface for text to go in the various boxes. Then you can place the panel inside a bigger dialog box, along with a large list box, and give it an interface for it's functionality, in this case parameters for a file name, a directory, and the option between load versus save. Put that together and you've got the standard Load/Save dialog box. Note how when you want to load or save a file you don't need to manipulate all the little text boxes and buttons of the dialog, you can follow the interface of giving it a file name, a path, and a few simple flags. In your case, there is no reason that the world needs to know that an aircraft requires two fonts. Each object should only care about it's directly contained elements. As for passing objects, sometimes it is appropriate to pass around a pointer to a big ball of stuff. Sometimes it isn't. It all depends on the details of the situation. Generally if any object is moving past a single level of indirection it is a smell. Moving past two levels of indirection means it is probably getting too intimate with other objects, knowing details it shouldn't. When you've got code that relies on four or five layers of indirection in one place, you know you've got code to clean up. Designing these systems so they are loosely coupled is difficult work. When you encounter a new situation you need experience to know what should be exposed and what should be contained. If you don't have experience, do some research and make an educated guess. If you guess wrong then you'll gain experience and make a better choice next time.
  15. The Sims has a lot of amazing tech in their rendering engine. Each version has different technology. The game uses some rather complex functionality to allow players to customize colors, texture patterns, and other visual aspects of objects. What happens depends on which version you are using. There are some guides like this that may help you.
  • Advertisement

Important Information

By using GameDev.net, you agree to our community Guidelines, Terms of Use, and Privacy Policy.

We are the game development community.

Whether you are an indie, hobbyist, AAA developer, or just trying to learn, GameDev.net is the place for you to learn, share, and connect with the games industry. Learn more About Us or sign up!

Sign me up!