C++ is used to program and create video games on different platforms.

What This Guide Covers

Whether you’re a complete beginner or transitioning from another engine, this comprehensive guide answers the most common questions about C++ and Unreal Engine development. You’ll learn when C++ is necessary, what alternatives exist, and how to make the best choice for your project goals.

The Short Answer: Blueprints vs C++

You can absolutely create games in Unreal Engine without knowing C++. Unreal’s Blueprint visual scripting system allows you to build complete games using a node-based visual interface instead of traditional code. Many successful indie games have been built entirely with Blueprints.

However, C++ becomes valuable when you need:

• Maximum performance optimization
• Complex gameplay mechanics
• Custom engine modifications
• Integration with third-party libraries
• Advanced AI systems

However to get the most out of UE and improve at the fundamentals, you should not be using blueprints or C++ exclusively. Ideally, you should learn how to use both. If you want to learn more about C++ vs Blueprints , we’ve discussed in another article about when to use Blueprints or C++ when developing games.

Is Unreal Engine good for beginners?

Unreal Engine is a great game engine for beginners as it provides access to a lot of templates and assets completely for free (unless your game earns >$1M gross annually) . However, it is also expansive and powerful enough for experienced developers as well. If you are familiar with other platforms, such as Unity or previous Unreal Engine versions, you will be able to jump right in and start creating video games using Unreal Engine C++. A virtual game and graphic studio that specializes in Unreal Engine C++ development can also be a great resource for learning the language and developing your skills.

The process of developing a game with Unreal Engine is not difficult to understand, but it does require a lot of time and practice, knowledge of the language, and commitment. And one of the very first questions is: where do I begin?

Do you need to know how to code for Unreal Engine?

Creating entire games with Unreal Engine can be a daunting task, but with the right knowledge and skills, you can make amazing programs. Some basic knowledge of coding—and C++ to an extent—is required, but it is not necessary to be an expert. The Unreal Engine is not just intended for developers but also for creators; and a game programmer is not limited to working with Unreal Engine.

It is even possible to create full-fledged games without any coding background. Popular gaming engines like Unity or Unreal Engine offer visual scripting tools or no-code solutions for managing game assets. Unreal has its Blueprint scripting process wherein you can use nodes to replace normal programming logic.

But if you want to dive into the nitty gritty, learning about the fundamental language of which the engine is based on a surefire way to greatly increase both your options and your efficiency. Additionally, many other game development platforms, such as Unity and GameMaker, use similar coding languages. Knowing how to code for these platforms will help you get started in the game development industry.

Learning Path Recommendations for Complete Beginners

1. Start with Blueprint Fundamentals
   • Complete Epic’s Blueprint tutorials
   • Build simple games (Pong, basic platformer)
   • Understand Unreal’s component system
2. Learn Basic C++ Outside Unreal
   • Master fundamental programming concepts
   • Practice with simple console applications
   • Understand object-oriented programming principles
3. Transition to Unreal C++
   • Start with simple C++ components
   • Gradually replace Blueprint functionality with code
   • Learn Unreal-specific C++ conventions and macros

READ MORE: Install and set up Unreal Engine with Visual Studio.

When is C++ essential then?

C++ coding becomes essential when you’re dealing with specific use cases and the blueprints system is not sufficient anymore.

• Performance-Critical Applications

C++ provides direct memory management and system-level control that Blueprint scripting cannot match. For AAA games, VR experiences, or applications requiring 60+ FPS with complex systems, C++ often becomes necessary.

• Advanced Game Systems

While Blueprints excel at prototyping and standard gameplay, certain advanced features require C++ implementation:

• Custom rendering pipelines
• Specialized physics calculations
• Multi-threaded operations
• Platform-specific optimizations

• Professional Development

Most professional game studios expect C++ knowledge for Unreal Engine positions. Understanding both Blueprint and C++ makes you more versatile and employable in the game development industry.

• Custom Gameplay Mechanics

With C++, you can implement complex gameplay logic that goes beyond what is possible with Blueprints. This includes creating custom character controllers, AI behaviors, and game rules.

• Creating components and 3D environments

Components are the basic building blocks of Unreal Engine. Components can be used to create 3D environments, menus, and other user interface elements. These components can be exported to other platforms.

• Advanced AI Systems

Create sophisticated AI systems using C++ for behavior and decision-making processes for non-player characters (NPCs) and other game elements such as custom pathfinding algorithms, decision-making systems, and behavior trees.

• Create logic and integrate with scripts

Logic is the code that controls how players interact with each component. Scripts are a special type of code that is more visual. Using both C++ and scripting for Unreal  allows for seamless development in their games.

• Test and debug games

Testing and debugging games is an important part of the game development process. When you work with mechanics created using C++, verifying that component will most likely require C++ knowledge as well. Problems that can be debugged include crashes, missing textures, and incorrect game logic.

Blueprint vs C++ Performance Reality

When Performance Differences Matter

The performance gap between Blueprint and C++ varies significantly by use case:

• UI and Menu Systems: Minimal difference
• Simple Gameplay Logic: Negligible impact for most games
• Heavy Calculations: C++ shows clear advantages
• Frame-Critical Systems: C++ often necessary for consistent performance

Hybrid Approach Benefits

Most successful Unreal projects use both systems strategically. Learn more here.

• Blueprints for: UI, game flow, designer-friendly tweaking
• C++ for: Core systems, performance-critical code, complex algorithms

Highly Recommended for Unreal C++ 

If you do decide to code using C++ for Unreal Engine, you will most likely download Visual Studio, the official IDE of choice for developing C++ games in Unreal Engine. It provides an extensive list of navigations, refactoring, auto-suggestions and syntax highlighting for C++ development.

However, Visual Studio also caters to C/C# and unfortunately, the support and tooling for C++ may seem relatively weaker at first glance. Furthermore, Unreal Engine has bespoke coding elements and syntax. This may lead to frustrations when developing Unreal C++ games in the IDE because some basic navigations and features such as syntax highlighting may be unresponsive, or may be unavailable completely.

For these cases, it is highly recommended to install a supplementary plugin like Visual Assist which improves the overall IDE experience and replaces the frustrating elements with tailored features made for C++ Unreal Engine development. It makes the IDE features responsive and adds “understanding” so that basic features such as code highlighting, search, and auto-suggestions work properly.

The post Do I Need To Know C++ For Unreal Engine? The Updated 2025 Guide first appeared on Tomato Soup.

If you want an edge over the competition, it’s important to get timely and accurate information about what game studios and teams are looking for now. Bonus points if you can get advice from someone who’s doing the actual hiring!

If that’s what you’re looking for, then you’re in luck today. That’s exactly what we have in store for you today. We had a chat with a game director that has had multiple years in the industry and has been involved with a lot of hiring decisions.

About the interviewee

The Whole Tomato team had a chat with Julian Bock (called Jules by friends and colleagues), an expert figure in the game development industry with almost two decades of experience. Based in Germany, Bock is currently working as the managing director at NUKKLEAR. Until just this March, he was the Director for Product Development at PLAION, the game development and publishing company responsible for the recently released and highly-acclaimed Kingdom Come Deliverance II.

We asked for his insights and comments about what’s going on in the game development industry and how that has affected how they look for new team members for their projects. 

Current State of the Game Development Industry

Jog hunting in the game development industry in 2025 is highly competitive owing mostly to the post-pandemic slump and the proliferation of AI-assisted development. These two factors have slowed down demand while at the same time increasing individual efficiency, making the competition tight, especially for new developers breaking into the industry.

For context, the pandemic spurred unprecedented growth (13% rate of return from 2017–2021), but expansion tapered dramatically to around 1% from 2021–2023. Now, it is only projecting 5% through 2028.

And for aspiring game developers or fresh graduates, the state of the game industry is one of the major (albeit uncontrollable) factors that decide how difficult it is to score your first role or job in as a gamedev.

Bock explains that during the pandemic, “we had a lot more time for entertainment.” But when the lockdowns gradually eased up, the demand for games slowed down but the companies and businesses still had to realize the investments made during the pandemic boom.

“We came to the point that a lot of more money was invested into this obviously booming industry which led to projects being started, a lot of more publishers, and a lot more developers.”

But inevitably, the market stabilizes and investments slow down. So this forms a problem for new developers wherein there had been still a lot of games being published because companies still had the budget from pandemic investments, but at the same time, there were fewer and fewer players than before.

The Reality of Modern Game Development Teams

Game development is fundamentally a team sport that requires long-term commitment. Most major projects operate on 3-5 year development cycles, with studios relying heavily on a stable core team of experienced developers. “It’s very important, in my view, that you start with a very strong, reliable core team,” explains Bock, who has managed teams ranging from 5 to 200+ people across various projects, including the recently released Kingdom Come: Deliverance 2.

This doesn’t mean newcomers are locked out—quite the opposite. Studios need a healthy mix of senior, regular, and junior developers for both cost reasons and for maintaining a pipeline of talent. The key is understanding where you fit in this ecosystem and how to position yourself for growth.

What It Really Takes to Get Hired in 2025

Tip 1: Scout the team you’re trying to join and see what you bring to the table.

Companies will always look for the best fit in terms of team composition. Regardless of your current skill level and experience, Bock also emphasizes how important it is to understand the team dynamics and composition of a usual game development team.

Teams can’t just be full of seniors—that becomes extremely expensive fast. There will always be space for less experienced devs. As mentioned above, studios need a healthy mix of senior, regular, and junior developers for both cost reasons and to have access to a broader set of skills.

So how to stand out as a junior dev? Understand the company and show them your potential and willingness to learn. 

Bock advises: “For the young people reading this, it’s important to know if you are being hired in a company,  [understand that] as a young developer, you can develop yourself while learning on the job, learning from the seniors, and getting insight of the realities from leadership.” 

If you are able to research and scout the company and the team look for answers to these questions:

• How big is the company I am joining? 
• Is it more of an indie or a mid to large-sized company?
• Do I know if the company is in the middle of producing a new game? 
• Are they looking for any specific specialization? Or are they filling in general gaps in the workplace?
• Do my skills fit the current project of the company? 
• What do I know about the genre of games being developed?
• Upon joining, what do I provide the company? Can this change if they train me?

Tip 2: Cultural Fit vs. Technical Skills

Another key consideration that Julian shared is to mind not only what skills you bring to the table, but also how you bring those to work. The output and pace of the project is dictated by the team building it. As someone who wants in on a project, you need to have certain skills and knowledge (or affinity for them), as well as a compatible mindset when joining the team.

Getting to keep a job is just as important as bagging it the first time around. A nail that sticks out gets hammered. Know your role, learn how to collaborate, and see how you can try out new things without slowing down your teammates in the process.

Ask yourself not only what the company can do for me, but also what can I do for the company—keeping it balanced, of course.

Tip 3: Flexibility is Your Greatest Asset

In connection with the last tip, as someone starting out in a new team, the most important trait for new developers isn’t necessarily technical prowess—it’s flexibility. “What is really important for young developers is being flexible,” Bock emphasizes. This means being willing to start at an appropriate level, prove your value and potential, and then negotiate your next step based on performance.

The games industry isn’t the highest-paying tech sector. With the same skillset and affinity for coding, developers who prioritize maximum compensation might find better opportunities in fintech or enterprise software, for instance. 

However, game development offers something unique: the opportunity to create experiences that generate genuine emotional responses in players. As Bock puts it, “You’re delivering an experience to the player… you’re delivering emotions.”

Tip 4: Do I specialize or do I generalize?

The eternal question of whether to specialize or develop broad skills depends heavily on the type of projects you want to work on. For small indie teams of 5-10 people, generalist skills are invaluable—you might need to handle everything from gameplay programming to UI design. However, larger AAA productions with teams of 100+ developers typically seek specialists: combat designers, vehicle systems programmers, or technical artists with specific expertise.

Most developers cannot afford to take long breaks as the average pay grade cannot sustain such long breaks. Devs don’t generally get any revenue share or royalties from the project they worked on too. After a release or at the start of a new game development cycle, devs have three main options:

• Continue post-launch to produce patches, expansion content, DLCs, etc, 
• Get reassigned to a new team to start/continue developing a new game
• Jump ship and start looking for a new project altogether

The smart approach for newcomers is to develop a solid foundation across multiple disciplines while building deeper expertise in one area that genuinely interests you. This gives you the flexibility to contribute to smaller teams while positioning yourself for specialized roles as you gain experience.

Bonus Tip: The AI Imperative

Perhaps the most critical advice for 2025 and beyond centers on artificial intelligence. “If I would be like a young graduate today… I think it’s most important to enter the AI game with clarity and dedication.” Bock advises.

While many roles in game development will likely be impacted or replaced by AI in the coming years, those who can effectively work with AI tools will become indispensable. “Some see AI as a threat, some as a chance. Don’t resist, try to rule while using it!” 

This trend is already visible across the industry. Companies like Ubisoft are experimenting with AI-powered procedural generation tools, while indie developers are using AI for everything from concept art to dialogue writing. Rather than viewing AI as a threat, emerging developers should embrace it as a powerful multiplier for their creativity and productivity.

Our note: Regardless of your stance on the usage of AI in the workplace, we cannot deny its usefulness in multiple areas of game development. Thus, new developers need to adapt to the demands of those who are hiring or else they risk being overshadowed by their AI-using peers.

Green flag, red flags for job hunters

What Studios Are Looking For

Beyond technical skills, studios value developers who understand the broader context of game development. This means grasping the business realities—budgets, timelines, and market pressures—that influence creative decisions. The best junior developers don’t just ask “What can the company do for me?” but try to keep a healthy balance and also consider “What can I do for the company?” as well.

Cultural fit matters enormously, especially for core team positions. Game development is inherently collaborative, and toxic team members can derail projects that represent years of investment. Studios look for people who can handle criticism, adapt to changing requirements, and maintain positive relationships under pressure.

Building Your Foundation

While formal education can provide valuable structure and networking opportunities, the industry increasingly values demonstrable skills over degrees. A strong portfolio showcasing completed projects—even small ones—carries more weight than academic credentials alone. Contributing to open-source projects, participating in game jams, or creating mods for existing games can provide the practical experience that makes a resume stand out.

The rise of accessible development tools like Unity, Unreal Engine, and Godot means there are fewer barriers to entry than ever before. You can download professional-grade software and start building games immediately. What matters is the quality of what you create and your ability to discuss your design decisions intelligently.

Looking Forward: The Consolidation Opportunity

While the current industry contraction might seem discouraging, it also represents an opportunity. The market is moving toward “more quality product, less product,” as Bock predicts. This means that skilled developers who can contribute to polished, memorable experiences will be in high demand.

The key is positioning yourself for this future by developing skills that complement rather than compete with AI, building a network within the industry, and maintaining the flexibility to adapt as the landscape continues to evolve. Whether you’re interested in indie development, mobile games, or AAA productions, the fundamental principle remains the same: focus on creating great experiences for players, and the career opportunities will follow.

Game development remains one of the most rewarding creative fields for those willing to embrace its challenges. The industry needs fresh talent with new perspectives, and there’s never been a better time to start building the skills that will define the next generation of gaming experiences.

Get Ahead with Visual Assist for Unreal Engine work

If you are applying and looking for a job involving Unreal, using game-focused development tools like Visual Studio with Visual Assist can help you work smarter, navigate large codebases faster, and spend more time creating rather than troubleshooting. Download and try it now for free!

The post How to get a job as a game developer in 2025 – Part 2: Insider advice from a studio game director first appeared on Tomato Soup.

If you’re in the market for your or your team’s SaaS fix, you’re in luck. This article will make your research a bit easier. In this blog, we discuss the value of one of the most powerful productivity extensions in Visual Studio and why plugins in general are still necessary in 2022.

What does Visual Assist do?

Visual Assist is a Visual Studio productivity plugin that is designed to help write C/C++ and C# code faster and easier.

VA does this by improving or adding built-in tools and features in Visual Studio with an efficient and a more powerful alternative. These benefits may manifest as more responsive menus, better code analysis tools, or even bespoke shortcuts that streamline complex processes into a single click.

Other articles can give a more complete explanation of what Visual Assist does, but in a nutshell, VA is a tool extension that improves a developer’s productivity.

How much is a developer’s time worth?

Not everyone realizes that time is the most expensive currency we exhaust every day. It is an indispensable and irreplaceable resource—and doubly so in the world of developers and programmers!

the average day for a developer costs a whopping $420…

Did you know that the average day for a developer costs a whopping $420? That’s around $3,000 weekly. That is why it is in the best interest of businesses and teams that the majority of a developer’s eight-hour workday is focused on actual programming. However, this also means that developers are getting pressured with shorter development cycles. A 2020 research found that codebases are increasingly getting larger, and pressure to deliver projects faster has increased in the past 10 years. And as larger and more complex codebases became the norm, demand for tools to support C++ developers has also ballooned.

From Sourcegraph: The Emergence of Big Code Survey

Is a Visual Studio code assistant the solution?

Going back to the main question, why is investing in Visual Studio extensions necessary? VS has made leaps and bounds in usability, efficiency, and support but the advantages are reduced due to increasing project requirements and time pressure.

For example,  there are still areas that lack extensive support and functionality. Game development projects, for instance, have resource-intensive tasks and unfamiliar syntax causing unintended behavior in the IDE. This unsupported niche is filled by plugins and is also why professionals need extensions to perform better. 

The core of development work is problem solving—not typing, navigating, or fixing syntax errors. They are part of the work, but they should not take more time than necessary. 

Visual Studio is a tool. Visual Assist is an enhancement. They are meant to simplify work and increase productivity. With increasing workloads and expectations, developers need to have more and better tools to produce quality work.

Dividing a developer’s attention into other tasks such as debugging small errors, shuffling through blocks of code, and waiting for builds to compile can stunt productivity—resulting in slower project turnaround time.

Some users may rely on native tooling, but as long as Microsoft cannot support every possible use case and application of Visual Studio, having performant plugins will still be a necessity for C/C++ developers. Besides, $129 for Visual Assist is a relatively low opportunity cost to get massive gains in productivity— making it an investment that pays for itself in as fast as two weeks.

The advantages of having Visual Assist

For those who transitioned to VS 2022, the shift to a 64-bit architecture has certainly fixed a few of the issues that long plagued the IDE. But a few problems persist to this day, such as:

• Tedious and repetitive tasks
• Superfluous processes
• Frustrating build and load times
• Unrecognized syntax and false errors

VA’s suite of features is specifically designed to alleviate these pain points with quick and responsive menus and options. “Fast performance is still one of [our] main advantages over other plugins,” notes Chris Gardner, lead developer of Visual Assist.

However, it’s also lightweight and works 100% alongside other VS plugins. “We believe it’s part of being a good member of the [plugin] ecosystem where [we] sit alongside others,” explains David Millington, a product manager of Embarcadero Technologies and Whole Tomato.

Visual Assist users can reallocate ~21% of their day to more pertinent tasks.

Feature Demo: example of time-saving feature (Code Inspection)

Here is a concrete example of how VA can save a ton of time. Code inspection is a nifty feature that checks code for quality issues and suggests the appropriate fixes.  

The two main advantages of Visual Assist over the native refactoring options are a) it automatically suggests corrections as you’re working on it, and b) it works just as well on large codebases.

Check out Visual Assist’s code inspection in action:

A webinar hosted by Visual Assist lead developer, Chris Gardner

Give Visual Assist a spin

If you’re still unsure whether investing into a small plugin is worth it, VA offers a 30-day trial for free. Experience it for yourself and see why VA users cannot go back to vanilla Visual Studio.

The post Why It’s Necessary to Invest in Visual Studio Extensions first appeared on Tomato Soup.

In this article, we will look at 13 interesting Visual Assist For Visual Studio 2022 features you may not know yet, but they will be definitely useful for you.

#1 How to quick fix code issues?

Visual Assist For Visual Studio 2022 automatically analyzes your C++ code and uses statistical analysis to find common programming errors. The place in the code where the error is found is underlined.

To find out the cause of the error, you need to hover over the underlined characters. If the problem in the code is dimmed or solid underlined, there is a quick fix available for the error. If the error is dotted underlined, no quick fix is available, but you can still find out the cause of the error.

#2 How to surround code with a snippet?

You can surround the selected part of the code with a snippet. Some snippets allow you to wrap only entire lines of code, while others can wrap code in the middle of a line.

You can surround some code with a snippet using the appropriate menu command or hotkeys that need to be specially configured.

#3 How to create a snippet from the selection?

You can quickly create snippets from ready-made code using Visual Assist For Visual Studio 2022. Just select the desired code and choose the menu command VAssistX -> Tools -> Create VA Snippet from the selection.

The snippet editor will open. In this editor, you can change the code, replace variables and constants with placeholders, and enter a title, description, and hotkeys to insert the snippet.

#4 How to debug crash dumps with VA Memory View?

Visual Assist Memory View is a tool that allows you to debug crash dumps when the call stack is corrupted or is in a release build.

Memory View displays the following data:

• The address. By default, the start address is the one pointed to by ESP/RSP.
• Content. This is the value that is stored in the address.
• Module. The name of the module where the memory address resides. This field is empty if the memory address is not in the module.
• Symbol name. The symbol at the memory address, if it is found or recognized.

#5 How to step over methods using the debugger?

Visual Assist For Visual Studio 2022 has a Step Filter tool that allows you to step over certain methods when debugging applications.

If the method in the parameter list contains another method, then, during debugging, we must first get inside the method that is in the parameters. If for some reason you want to step over this method, then you can add it to the Step Filter.

#6 How to add source links to comments?

With Virtual Assist you can add source links to comment substrings. They connect comments to external applications or websites such as bug trackers, documentation, case managers, etc.

A source link opens when you double-click on it. Hovering the mouse over a link will open a tooltip that contains basic information about the connected application or website.

#7 How to go to a related symbol?

This feature allows you to simplify the process of navigating through the code and quickly jump to the associated symbol by using the current symbol’s location.

Depending on the type of symbol, you can go to different places such as base class or method, inherited class or method, type, hashtag, header file, constructor, declaration, etc.

#8 How to list all classes and methods in the file?

The Context field allows you to list all classes and methods declared or implemented in the current file. Also, you can filter the opened list. The Context field is located on the left side of the Visual Assist navigation bar.

In addition to classes and methods, the list can also include member variables, structures, enumerations, defines, events, properties, and regions.

#9 How to automatically encapsulate a field?

The encapsulate field command is available from the refactoring menu. It allows you to automatically create methods for reading and writing the value of a field while restricting access to the field itself. When you call this command, a dialog box opens in which you can edit the name of the setter and getter, as well as change the visibility of the field.

#10 How to create a declaration or implementation?

If a method in a class has only an implementation, then with Visual Assist For Visual Studio 2022 you can automatically generate its declaration. To do this, select the appropriate command from the refactoring menu. The method declaration and implementation will have the same parameters.

If a matching header file exists, then the declaration will be placed in it. Otherwise, the declaration will be generated in the source file.

Similarly, you can generate a method implementation for an existing method declaration.

#11 How to document a method?

Visual Assist For Visual Studio 2022 allows you to easily document a method. To do this, select the declaration of the required method and click the required command from the context menu.

After that, a block of comments will appear before the method. This block will list the parameters of the method and the return value in separate lines.

#12 How to repair the case?

Virtual Assist has an automatic case correction feature. You can enter characters in the wrong case and they will be automatically corrected. If there is more than one way to correct the value, no automatic correction occurs.

#13 How to highlight syntax?

Visual Assist For Visual Studio 2022 allows you to add or change your IDE’s code highlighting. You can choose colors that suit you for classes, variables, preprocessor macros, enum members, methods, and namespaces.

In addition, it is possible to add highlighting to various components, such as tool windows.

Choose Visual Assist For Visual Studio 2022 and make the application development process quick and easy.

The post 13 Things About Visual Assist For Visual Studio 2022 You May Not Have Known first appeared on Tomato Soup.

In the presentation, VAX lead developer, Chris Gardner, takes you through the steps of coding a modified powerup into a shooter game using Visual Studio and the Unreal Editor. 

Chris gives you a concrete idea of what games look like under the hood and how to set expectations before you get into actual game development. He also demonstrates in detail an important concept in Unreal coding—referencing blueprints in C++ code. 

We’ve summarized the most important takeaways from Chris’s presentation below.

Important Takeaways 

Prepping yourself

• Game development is complex, and there are many possible ways to be involved. For example, you can be a programmer, a designer, or an artist, among other roles. 
• Learn how to find, understand, and apply new information to your code. Great Googling skills are vital soft skills to have as a developer.
• Learn from mistakes. Having an “I want to learn how to fix this” mindset when dealing with frustrating errors is the best way to learn new things.
• Similarly, having an “I just want to learn more” mindset is just as useful.
• If you want to finish creating a game, use a game engine; if you want to learn more about game development, make your own game engine.
• More code inspection and Unreal features are coming for Visual Assist.

Chris’s tools and Unreal Engine setup

• Visual Studio 2022
• Unreal Engine and Unreal Editor 4.27
• Visual Assist 2022.1 plugin (highly recommended) 

Handy Visual Assist shortcuts for game development

• Open file in Solution (Shift + Alt + O) 
• GoTo Implementation (Alt + G)
• GoTo Related (Shift + Alt + G)
• Open Quick Action and Refactoring menu (Shift + Alt + Q)
• Add includes (hover or select unknown symbol)

Check out the list of Visual Assist keyboard shortcuts. These are the default installation settings.

Important time stamps

Here are the time stamps for Chris’s webinar presentation.

• Main body of webinar (9:02)
• Concept to playtesting (13:55)
• Initializing projects: Setup and tools (16:40)
• Setting up Visual Assist for the first time (22:43)
• Base classes, methods, and referencing blueprints using C++ (23:30)
• Unreal editor particle system (49:38)
• Audience question and answer (59:25)

If you’re interested in learning more about the things mentioned in this summary in greater detail, you can browse through our replays here.

The post Recap: Improving your game development experience (with VAX lead dev) first appeared on Tomato Soup.

In this blog, we’ll talk about a few things you might want to know before you get started in the video game industry. 

The video game industry— by the numbers

Many new programmers aspire to land careers in the video game industry. Who wouldn’t want to make triple-A games for a living, right?

In fact, the video game industry has been rising for years now, fueled by more and more players and indie gaming studios. This trend has brought unprecedented growth year after year, both in the number of users and in the quality of games.

It’s no wonder that many new developers—many of whom were gamers themselves at some point—try to get into the game industry.

Things to consider before deciding on a career as a game developer

Before finalizing a career choice in game development, there are a few things you have to consider first. Most people miss one key thing—playing games is an entirely different arena from creating one. 

A career in game development involves investing a lot of time in practicing and learning (months and years even) and then more hours of actual work and debugging.

Game development is like producing an indie film. The goal is relatively simple to visualize, but as soon as you start doing it, you find that there are a lot of hidden elements and complexities like finding actors, sourcing equipment, or writing a script, among other things.

However, if you can look past the apparent startup hurdles (which are present in any career or hobby), then you can start practicing your skills and be on your way to becoming a full-time game developer.  

Here are a few other questions to ask before deciding on a career in game development: 

• What programming languages will you use?
• Are you more of a game artist or a game programmer?
• How much time and resources are you willing to invest in learning?
• Are you doing this as a recreational hobby or to build your resume?

Tip #1: Start with simple projects

One of the best ways to start is by getting some hands-on experience by completing a project from start to finish. You can start with something simple, like a game of Pong or a side scroller using the language of your choice. 

But don’t let the “beginner” tag fool you!  

You will find that even the most simple of games require a lot of time and effort to create. However, creating a game from scratch will serve as a great introduction to the hidden complexities of game development, such as:

• Creating objects
• Programming player input and controls 
• Adding simple AI for NPCs
• Object physics
• Game conditions and objectives
• Game UI and menus

You can also find completed projects from other developers to use as a benchmark for your own projects.  For example, this Pong source code is available on GitHub and is open for the whole community to examine, copy, modify, experiment with, and more.

And if you get stuck on something, don’t be afraid to ask on gamedev forums such as Reddit or Stack Exchange. You would be surprised by the number of people who would be willing to help. 

There are also tutorials on YouTube if you prefer videos. Full-fledged courses, both paid and free, are also available on popular providers such as Coursera or Udemy.  You just have to look for the one that fits your learning style the best. 

When you finish your first game, remember that it doesn’t have to be super polished or bug-free. The important thing here is to experience game development and all things related.

Tip #2: Build upon pre existing resources with game engines

If you’re feeling a bit more adventurous, you can try a different approach by using game engines like Unity or Unreal Engine. 

The main advantage of using game engines is access to pre programmed templates and assets. In fact, many new developers go this route so they can focus on game design and avoid many of the technical (and often tedious) details for later.

For example, something basic like drawing text using Direct X code is several degrees more complex than using a built-in GUI in Unity or Unreal. These instances tend to frustrate beginners and steer them away from ever finishing their first game.  

Another advantage of using these big game engines will give you access to a very active community of other developers as well as some very useful documentation.

• Unreal Engine Documentation
• Unity Documentation

For instance, you can head over to Unreal Engine’s starter projects for a list of “simplified gaming experiences,” which allow you to try a design approach for a specific game type.

Tip #3: Maximize the tools you are using

This may seem obvious, but you need to familiarize yourself with the tools you are using. Whether you are focusing on graphic design with game engines or coding complicated game mechanics, a certain level of mastery will greatly improve your workflow.

If you are coding in C++, we recommend using a dedicated coding environment IDE like Visual Studio as it’s free and natively supports the language.

Then when at some point you feel that the coding environment you are using is limiting you, it may be prudent to install productivity plugins like Visual Assist. This will greatly help with navigating, managing, and writing huge code projects (which is almost always the case with game development projects). It also has dedicated features and support for Unreal Engine.

In summary

Here’s a quick recap on how you can get started with your game development career.

• Understand that playing games is different from programming them
• Determine how much time and effort you can allocate to learning
• Start with simple projects to build experience
• Utilize all the resources available 
• Maximize your efficiency with the right tools

Always remember that there is no clear-cut path to becoming a game developer. There are people who start as solo hobbyists, while some were recruited due to their experience in similar fields. But what you can do is pick a project you like, and keep practicing until you reach your goal!

Bonus tip: Watch how other game developers work

Trying to understand how to program games through a blog article can take you only so far. Try to find more experienced developers and see how to integrate some of their best practices and habits into your workflow.  

And as an alternative, you can register for Whole Tomato’s webinar on ways to improve game development experience. This short webinar will showcase how to do simple projects in Unreal Engine.

The post Tips for Aspiring Game Developers first appeared on Tomato Soup.

Let’s start! 

1. Rename and Aim for Meaningful Names You might be surprised by the first point on our list. 

Is rename added to C++11 as a feature? 

No, it’s definitely not just an element of C++. In fact, having good names is not a feature of any programming language, as it depends on your style. The compiler can take any names, including single letters and even almost any Unicode character. Thanks to better IDE support and powerful text editors, we can now avoid shortcuts and rely on full and meaningful names. 

And what’s most important is that we can leverage extra refactoring tools, like those from Visual Assist, to fix code with the legacy style. 

Let’s have a look at the following class: 

class PBrush { 
public: 
	PBrush(); 
	~PBrush(); 

	bool Gen(HDC r) { } 
	bool IsAval() const { return aval; } 

private: 
	bool aval; 
	
	HGLOBAL m_hGlobal; 
	LPBITMAPINFO lpBitmap; 
	LPBYTE lpBits; 
	HDC ReferenceDC; 
	
	RGBQUAD m_pal[256]; 
}; 

Read the above code and think about potential naming issues. Is the code clear and descriptive? What would you change? 

Or take a look at the following function, which uses this PBrush objects: 

std::vector<PBrush*> FilterAvalBrushes(const std::vector<PBrush*>& brs) { std::vector<PBrush*> o;
	ULONG totalBCount = 0; 
	size_t totalBitmaps = 0; 
	
	for (size_t i = 0; i < brs.size(); ++i) { 
		if (brs[i]->IsAval()) { 
			o.push_back(brs[i]); 
			++totalBitmaps; 
			totalBCount += brs[i]->GetByteCount(); 
		} 
	} 
	
	// make sure they have some bits ready: 
	for (size_t i = 0; i < o.size(); ++i) { 
		if (!o[i]->Bits()) 
			Log("ERROR, empty bitmap!"); 
	} 
	
	Log("Byte count %d, total bitmaps %d", totalBCount, totalBitmaps); return o; 
}

How could we improve the code? 

You might be tempted to say that it’s better to leave old code and not touch it since other systems might depend on it. However, adding or changing to better names and keeping it useful to other systems is very simple. In most cases, you can find and replace old names or use Rename from Visual Assist. 

Visual Assist has a powerful feature for renaming objects and making sure the code compiles after this transformation. It was also one of the earliest VA features and enabled using this refactoring capability years before Visual Studio added it. 

You can invoke the rename tool in many situations. 

The simplest way is to hit a key shortcut when your cursor is inside a particular name ( Shift + Alt + R by default). For example, let’s say that I’d like to rename bool aval, so I move my cursor there and invoke the dialog, and then I can see the following window: 

Another option is to write a new name, and then VA will show a handy context menu where you can invoke the rename or see the preview window before making the changes. 

What other things can you do with rename? 

Improve consistency of names. For example, your style guide might suggest adding m_ before each nonstatic data member for classes. So you might quickly improve it and add this prefix for classes that don’t share this style. In our example, some names start with m_ while others don’t. 

It’s not only variables and functions but also things like enumerations and namespaces. 

But most importantly, what name would be better for aval? Do you prefer m_isAvailable ? or Available ? I’ll leave it as an exercise. 

2. Extract Smaller Functions 

Here’s another example to fix: 

// number of data components 
switch ( format ) 
{ 
case GL_RGB: 
case GL_BGR_EXT: components = 3; break; 
case GL_RGBA: 
case GL_BGRA_EXT: components = 4; break; 
case GL_LUMINANCE: components = 1; break; 
default: components = 1; 
} 

GLuint t; 
glGenTextures(1, &t); 

// load data 
HBITMAP hBmp = (HBITMAP)LoadImage(NULL, fname, IMAGE_BITMAP, 0, 0, LR_LOADFROMFILE | LR_CREATEDIBSECTION); 
if (hBmp == NULL) 
	return 0; 
	
// rest of code... long code

The above code is just a part of some longer function that loads, opens a file, loads bytes, and creates an OpenGL texture object with the loaded data. One thing that we might immediately do is to make this function smaller. More compact functions are easier to read and allow for more code reuse.  We can see that it has several smaller subtasks, so it would be better to extract them into separate parts. For example, we can implement FormatToComponents: 

And when you select this context menu, you’ll get the following dialog: 

After some adjustments (for example, we don’t need to take components as input argument), we can prepare the following code: 

int FormatToComponents(GLenum format) { 
	switch (format) { 
	case GL_RGB: 
	case GL_BGR_EXT: return 3; 
	case GL_RGBA: 
	case GL_BGRA_EXT: return 4; 
	case GL_LUMINANCE: return 1; 
	} 
	return 1; 
} 

And then call it from our initial function: 

GLuint LoadTextureFromBmp(const char *fname, GLenum format, GLuint filter) { const int components 
	= FormatToComponents(format);  

This not only gave us shorter, cleaner code, but also we can now mark our variable as const, which even improves the quality. Additionally, this function might be reused in some other places of the system. 

Here are the general rules for the extraction by VA: 

Symbols available globally, or within the class of the original and new methods, are not passed via a parameter list. 

Symbols used only in the right side of expressions (i.e., not modified) are passed by value. Symbols used in the left side of expressions (i.e., assigned) are passed by reference. Symbols referenced with dot notation within the extracted code (e.g., classes and structs) are always passed by reference. 

When a newly created method assigns a value to only one symbol, that symbol is passed by value and the assignment is done in the original method via return value. 

Symbols local to extracted code become local to the new method; they are not passed.

 3. Improve Function Interfaces 

Let’s now challenge ourselves with this one: 

bool Init2d(HDC hdcContext, FontMode fm, HFONT hFont, GLuint iWidth, GLuint iHeigth, GLuint iTexture, bool forceBold, bool forceItalic, size_t numGlyphs); 

It’s a member function in GLFont that is responsible for creating a texture font from a Window font. We can later use this created object to draw text in an OpenGL application. 

Isn’t it worrying that this function takes nine input arguments? 

And here’s an even more suspicious-looking call site: 

glFont.Init2d(const_cast<CGLApp *>(glApp)->GetHdc(), fmBitmap, hFont, iWidth, iHeight, 0, false, false, 256);

Some books suggest that if you have more than 5… or 7, then it’s some worrying code smell.  Such long lists of function arguments are hard to read, and caller sites might easily put them in a wrong order. Another issue is that there are a few boolean parameters, and it’s hard to see what they mean from the caller perspective. 

You can use Change Signature to modify all parts of a signature, including: 

• Method name 
• Return type 
• Visibility 
• Parameter names 
• Parameter types 
• Parameter order 
• Number of parameters 
• Qualifiers 

The plan for our function is to introduce a structure that would hold all parameters. We can do it by simply copying the parameter list and putting it into a structure above the function declaration: 

struct FontCreationParams { 
	GLuint iWidth; 
	GLuint iHeigth; 
	GLuint iTexture { 0 }; 
	bool forceBold { false}; 
	bool forceItalic { false}; 
	size_t numGlyphs { 256 }; 
}; 

As you can see, I even assigned some default values. 

And then we can change the signature in two steps: 

1. Add new argument to the function: const FontCreationParams& param with a default value of TODO. 

2. And then, again remove those extra arguments. 

Then you might compile code and fix call sites. 

The final code might look as follows: 

FontCreationParams params; 
params.iWidth = iWidth; 
params.iHeigth = iHeight; 
glFont.Init2d(const_cast<CGLApp *>(glApp)->GetHdc(), fmBitmap, hFont, params);

With this approach, if you need some more parameters (or you need to alter them), it’s just a matter of modifying the structure, and the function declaration will be the same. 

While you can do such a change manually, Visual Assist makes it much more comfortable and takes care of most of the cases at the call site. So this significantly simplifies and automates the process when you have many function calls. 

So far, we discussed basic principles for code modernization, but how about automation? Can we use extra tools that would tell us what to change in our code? 

Let’s see the fourth point. 

4. Enable Code Inspections 

Since a few years ago, Visual Assist has come with code Inspections that automatically check your code and pinpoint any issues. 

Code Inspection analyzes C/C++ for specific code quality issues as you edit. The feature, based on LLVM/Clang, warns you of issues in your code and if possible, suggests and applies quick fixes. 

You can enable them via Settings or as shown below: 

You can read the full description of Inspections in the excellent documentation website Introduction to Code Inspection and also see our previous article where we dive a bit deeper A Brief Introduction to Clang-Tidy and Its Role in Visual Assist – Tomato Soup. 

Currently,  we have almost 30 code inspections, and the number grows with each revision: List of Code Inspections. 

They range from checking .empty() vs size() , using emplace_back(), nullptr usages, and many more. They can help not only with code modernization but even with finding some performance issues in code. It’s like a small code analysis run on the code. 

Let’s  take a look at one related to for loops. 

5. Make For-Loops More Compact 

One of the coolest elements of C++11 style comes from using simpler for loops. This is especially important for code that uses containers from the Standard Library. 

For example, before C++11, you had to write: 

std::vector { }... 
for (std::vector<int>::iterator it = vec.begin(); it != vec.end(); ++it) std::cout << *it << '\n'; 

Now, this can be simplified with this simple syntax: 

std::vector<int> vec { 1, 2, 3, 4, 5, 6 }; 
for (const auto& elem : vec) 
	std::cout << elem << '\n';

Why not automate this transformation? 

VA identifies places where you can use this modern syntax and then rewrites loops for you. 

Consider this example: 

std::vector<PBrush*> FilterAvalBrushes(const std::vector<PBrush*>& brushes) { // ... 
	for (size_t i = 0; i < brushes.size(); ++i) { 
		if (brushes[i]->IsAval()) { 
			out.push_back(brushes[i]); 
			++totalBitmaps; 
		} 
	} 
} 

When code inspections are enabled, we can see the following suggestions:

What’s nice about Visual Assist is that it’s very smart and tries to deduce the correct loop syntax. 

For example, when our vector holds pointers, then the converted loop is as follows: 

std::vector<PBrush*> FilterAvalBrushes(const std::vector<PBrush*>& brushes) { // ... 
	for (auto brushe : brushes) { 
		if (brushe->IsAval()) { 
			out.push_back(brushe); 
			++totalBitmaps; 
			totalBCount += brushe->GetByteCount(); 
		} 
	} 
} 

But when we change the type into const std::vector<PBrush> (so it holds not pointer but “full” objects), then the loop is as follows: 

for (const auto & brushe : brushes) { 
	if (brushe.IsAval()) { 
		out.push_back(brushe); 
		++totalBitmaps; 
		totalBCount += brushe.GetByteCount(); 
	} 
}

The system is smart and avoids situations where you’d copy objects during loop iteration, as it’s more efficient to use references. 

That’s just a taste of what you can automatically do with Visual Assist and its code inspections! 

Summary 

In this article, you’ve seen five suggestions on how to check and improve your code. We started with something fundamental but often skipped: naming. Then we made functions smaller and with better interfaces. And at the end, we enabled code inspections so that Visual Assist can automatically identify more things to repair. 

In the last item, we looked at loop transformation, which is available from C++11. Thanks to Visual Assist, we can automate this task and quickly modernize our code to the newer standard 

After such refactoring, we aim to have safer, more readable code. What’s more, with more expressive code, we can help the compiler to identify potential errors. This is just a start, and stay tuned for the next article where you’ll see other code modernization techniques: override keyword, nullptr, enum class, auto type deduction, and deprecated headers.

The post How to Modernize C++ Code with Visual Assist in Five Easy Steps first appeared on Tomato Soup.

1. Install Visual Assist

1. Exit all instances of Visual Studio.
2. Run the .exe installer you downloaded.
3. Select the IDE(s) you want to install to.

2. Open your game solution

Visual Assist will come alive after it finishes parsing.

3. Look around

Open the Extensions > VAssistX menu. You will use the menu primarily to open tool windows, review keyboard shortcuts, and access the options dialog.

Appreciate the understated UI to Visual Assist. There are just a few visible changes.

4. Change a few settings

If you like meaningful syntax coloring, open the options dialog for Visual Assist and apply coloring to more of the UI.

If you highlight the current line, choose a thin frame that doesn’t obscure your code.

Visual Assist can add important information to tooltips when hovering over a symbol, such as comments from base classes. This is very helpful in UE4, as base class comments are the documentation.

Visual Assist can analyze your code and suggest improvements. Enable Code Inspections to see blue underlines where code might be improved. Visual Assist can even modernize your code for you! We will show how later.

Then, open the options dialog to Visual Studio and eliminate the redundant navigation bar. The version in Visual Assist includes the functionality of the built-in one.

After making the changes, Visual Studio is ready to use.

5. Navigation in UE4

Search for and open files using Alt + Shift + O. Precede a search filter with a hyphen to exclude symbols (negative filtering).

Understand and navigate the inheritance hierarchies of UE4 by using Alt + Shift + G on a class name. The Alt + Shift + G shortcut works on many types of symbols, try using it on a virtual method.

Source files in UE4 can be thousands of lines long. Use Alt + M to search for and navigate to methods inside the current file.

Find references to a symbol using Alt + Shift + F. Visual Assist’s find references is fast and accurate inside huge solutions like UE4. Try cloning your results to save them by clicking the Clone Results button or using the right-click menu.

Hover over a virtual method to see comments from base classes. Base class comments often contain useful documentation.

6. Refactoring in UE4

Access refactoring tools using the keyboard shortcut Alt + Shift + Q, or by hovering over a symbol and clicking the tomato icon that appears. The contents of the Alt + Shift + Q menu depend on the symbol.

It is common in UE4 to override virtual methods, such as Tick or SetupPlayerInputComponent. Visual Assist can implement these methods for you. Click on your class name and then use Alt + Shift + Q.

The Implement Methods dialog is searchable, and you can implement more than one method at once.

Visual Assist will intelligently add a call to the Super class version of the method for you when appropriate.

You will see blue underlines below code which could be modernized. This is Code Inspection.

Visual Assist can refactor the code for you! Use Alt + Shift + Q on the underlined symbol.

If you need to change the return type, parameters, or the name of a method you can use Change Signature. Edit the method definition in the window. References and call-sites to the method will be updated, so you won’t miss anything.

7. Tips

There is a lot of special functionality built into Visual Assist for UE4, such as suggestions for U* macros. The more you can use Visual Assist, the more opportunities to make your life a little easier in UE4.

You may find the built in IntelliSense to be unusably slow, or that it often adds red underlines to correct code in UE4. IntelliSense can be disabled. Visual Assist provides all the intelligent tooling expected in a modern C++ development environment.

You can throttle the initial parse in the Performance tab of the Visual Assist options dialog. By default, the one-time parse uses all available resources to finish as fast as possible.

For more information or support check out our forum and documentation.

Some features mentioned above require the latest build, check here for updates.

The post Getting Started with UE4 and Visual Assist first appeared on Tomato Soup.