Summary: To update a key in a dictionary if it doesn’t exist, you can check if it is present in the dictionary using the in keyword along with the if statement and then update the key-value pair using subscript notation or update() method or the * operator. Another workaround for this is, using the setdefault(key[, default]) method which updates the dictionary with the key-value pair only if it doesn’t exist in the dictionary otherwise, it returns the pre-existing items.

Problem: Given a dictionary; how to update a key in it if the key does not exist?

Example:

device = { "brand": "Apple", "model": "iPhone 11",

} < Some Method to Check if key-value pairs "color" : "red" and "year" : 2019 exists or not and then update/insert it in the dictionary > print(device)

Output:

{'brand': 'Apple', 'model': 'iPhone 11', 'color': 'red', 'year': 2019}

To solve our problem statement, let us follow a modular approach and break down our discussion in this article into three parts.

1. In the first section let us discuss the methods to update or insert a key,
2. In the second section, we shall be discussing the methods to check if the key is present in the dictionary,
3. Finally, we shall merge our concepts to reach the final solution.

Without further delay let us dive into the solutions right away.

Section 1: Insert/Update A Key In A Dictionary

Method 1: Create A New Key-Value Pair Assign It To Dictionary | Subscript Notation

We can create a new index key and then assign a value to it and then assign the key-value pair to the dictionary. Let us have a look at the following program which explains the syntax to create a new key-value pair and assign it to the dictionary:

device = { "brand": "Apple", "model": "iPhone 11",

} device["year"] = 2019

print(device)

Output:

{‘brand’: ‘Apple’, ‘year’: 2019, ‘model’: ‘iPhone 11’}

Method 2: Use The update() Function

The update() method is used to insert or update a specific key-value pair in a dictionary. The item to be inserted can also be another iterable. Also, if the specified key is already present in the dictionary then the previous value will be overwritten.

The following code demonstrates the usage of the update() method:

device = { "brand": "Apple", "model": "iPhone 11",

} device.update({"year" : 2019})

print(device)

Output:

{'brand': 'Apple', 'model': 'iPhone 11', 'year': 2019}

Method 3: Using The * Operator

We can combine an existing dictionary and a key-value pair using the * operator. Let us have a look at the following code to understand the concept and usage of the * operator to insert items in a dictionary.

device = { "brand": "Apple", "model": "iPhone 11",

}

device = {**device,**{"year":2019}}

print(device)

Output:

{'brand': 'Apple', 'model': 'iPhone 11', 'year': 2019}

Disclaimer: In the above methods if we do not check the presence of a key in the dictionary, then the value will be overwritten in the dictionary if the key and value are already existing in the dictionary. Now, that brings us to the second section of our discussion!

Section 2: Check If A Key Is Present In A Dictionary

Method 1: Using The in Keyword

The in keyword is used to check if a key is already present in the dictionary. The following program explains how we can use the in keyword.

device = { "brand": "Apple", "model": "iPhone 11", "year":2018

} if "year" in device: print("key year is present!")

else: print("key year is not Present!") if "color" in device: print("key color is present!")

else: print("key color is not present!") 

Output:

key year is present!

key color is not present!

Note: Just like the in keyword, we can use the not in keyword to check if the key is not present in the dictionary.

Method 2: Using keys() Function

keys() is an inbuilt method that extracts the keys present in a dictionary and stores them in a list. Thus with the help of this inbuilt method, we can determine if a key is present in the dictionary.

Let us have a look a the following program to understand how to use the keys() method and check the availability of a key in the dictionary:

device = { "brand": "Apple", "model": "iPhone 11", "year":2018

} if "year" in device.keys(): print("key year is present!")

else: print("key year is not Present!") if "color" in device.keys(): print("key color is present!")

else: print("key color is not present!") 

Output:

key year is present!

key color is not present!

Method 3: Using has_key() Function

If you are using Python 2.x then you might fancy your chances with the has_key() method which is an inbuilt method in Python that returns true if the specified key is present in the dictionary else it returns false.

Caution: has_key() has been removed from Python 3 and also lags behind the in keyword while checking for the presence of keys in a dictionary in terms of performance. So you must use avoid using it if you are using Python 3 or above.

Now let us have a look at the following program to understand how we can use the has_key() method:

device = { "brand": "Apple", "model": "iPhone 11", "year":2018

} if device.has_key("year"): print("key year is present!")

else: print("key year is not Present!") if device.has_key("color"): print("key color is present!")

else: print("key color is not present!") 

Output:

key year is present!

key color is not present!

Phew!!! Now, we are finally equipped with all the procedures to check as well as update a key in a dictionary if it does not exist in the dictionary. That brings us to the final stages of our discussion where we shall combine our knowledge from section 1 and section 2 to reach the desired output.

Update Key In Dictionary If It Doesn’t Exist

Solution 1: Using Concepts Discussed In Section 1 and Section 2

Since we are through with the concepts, let us dive into the program to implement them and get the final output:

device = { "brand": "Apple", "model": "iPhone 11",

} # Method 1 : Create a New Key_Value pair and check using the in keyword

if "color" not in device: device["color"] = "red" # Method 2 : Use update() method and check using the not in keyword

if "year" not in device.keys(): device.update({"year" : 2019}) # Method 2 : Use * operator and check using the not in keyword

if "brand" not in device.keys(): device.update({"brand" : "Samsung" })

else: print(device)

Output:

{'brand': 'Apple', 'model': 'iPhone 11', 'color': 'red', 'year': 2019}

Solution 2: Using setdefault() Method

setdefault() is an inbuilt Python method which returns the value of a key if it already exists in the dictionary and if it does not exist then the key value pair gets inserted into the dictionary.

Let us have a look at the following program which explains the setdefault() method in python:

device = { "brand": "Apple", "model": "iPhone 11", "color": "red"

} device.setdefault('year',2019)

print(device)

Output:

{'brand': 'Apple', 'model': 'iPhone 11', 'color': 'red', 'year': 2019}

Conclusion

I hope after reading this article you can check and update values in a dictionary with ease. In case you have any doubts regarding Python dictionaries, I highly recommend you to go through our tutorial on Python dictionaries.

Please subscribe and stay tuned for more interesting articles!

Where to Go From Here?

Enough theory, let’s get some practice!

To become successful in coding, you need to get out there and solve real problems for real people. That’s how you can become a six-figure earner easily. And that’s how you polish the skills you really need in practice. After all, what’s the use of learning theory that nobody ever needs?

Practice projects is how you sharpen your saw in coding!

Do you want to become a code master by focusing on practical code projects that actually earn you money and solve problems for people?

Then become a Python freelance developer! It’s the best way of approaching the task of improving your Python skills—even if you are a complete beginner.

Join my free webinar “How to Build Your High-Income Skill Python” and watch how I grew my coding business online and how you can, too—from the comfort of your own home.

Join the free webinar now!

The post How To Update A Key In A Dictionary In Python If The Key Doesn’t Exist? first appeared on Finxter.

Miniaudio is a cross platform open source C library for implementing low level audio functionality including playback and capture. MiniAudio is released under either public domain or MIT No Attribution licenses and amazingly enough is implemented as a single .H file with no external dependencies (except optionally stb_orbis if Ogg Vorbis format support is desired).

Miniaudio features include:

• Your choice of either public domain or MIT No Attribution.
• Entirely contained within a single file for easy integration into your source tree.
• No external dependencies except for the C standard library and backend libraries.
• Written in C and compilable as C++, enabling miniaudio to work on almost all compilers.
• Supports all major desktop and mobile platforms, with multiple backends for maximum compatibility.
• Supports playback, capture, full-duplex and loopback (WASAPI only).
• Device enumeration for connecting to specific devices, not just defaults.
• Connect to multiple devices at once.
• Shared and exclusive mode on supported backends.
• Backend-specific configuration options.
• Device capability querying.
• Automatic data conversion between your application and the internal device.
• Sample format conversion with optional dithering.
• Channel conversion and channel mapping.
• Resampling with support for multiple algorithms.
  
  • Simple linear resampling with anti-aliasing.
  • Optional Speex resampling (must opt-in).
• Filters.
  
  • Biquad
  • Low-pass (first, second and high order)
  • High-pass (first, second and high order)
  • Second order band-pass
  • Second order notch
  • Second order peaking
  • Second order low shelf
  • Second order high shelf
• Waveform generation.
  
  • Sine
  • Square
  • Triangle
  • Sawtooth
• Noise generation.
  
  • White
  • Pink
  • Brownian
• Decoding
  
  • WAV
  • FLAC
  • MP3
  • Vorbis via stb_vorbis (not built in – must be included separately).
• Encoding
• Lock free ring buffer (single producer, single consumer).

Miniaudio is available on GitHub and has solid documentation available here and several examples available here. Installation consists of downloading and #include’ing the header and that is it, making this a remarkably simple library to get started using. There are also unofficial language bindings for Go, Rust and Python available as well. You can learn more about the Miniaudio library in the video below (or view here on Odysee).

Last week, during Microsoft Ignite we announced the general availability of the new Azure VMware Solution. Designed, built, and supported by Microsoft, Cloud Verified by VMware, running VMware Cloud Foundation technologies, Azure VMware Solution enables customers to extend or migrate VMware workloads to the cloud seamlessly. Organizations can maintain existing VMware skills and operational processes, running VMware Cloud Foundation technologies, and leverage the benefits of Azure—all at the same time.

Since announcing the preview, we’ve seen tremendous interest from businesses for Azure VMware Solution. Driven in part by organizations adapting to and recovering from the global health crisis, organizations are increasingly adopting the cloud to ensure continuity, resiliency, and cost efficiency for their business.

As always, Microsoft is focused on delivering solutions that meet our customers where they are today. In a time where speed, simplicity and skill retention are critical, Azure VMware Solution provides organizations with a fast path to the cloud, so your business can continue to use the VMware platform you know, and modernize on-premises workloads at your pace.

Engineered to meet you where you are

The goal of Azure VMware Solution has always been to deliver the best, most secure, most functional cloud of choice for our customers. As a first-party Microsoft Azure service, built in partnership with VMware, we bring the best of both platforms together to deliver a high quality, integrated solution.

Azure VMware Solution has been engineered as a core Azure compute service to deliver you the speed, scale, and high availability of our global infrastructure. With a focus on simplicity the solution features a unified Azure portal experience, and seamless access to other Azure resources. Our Microsoft and VMware engineering teams also worked closely together to deliver new functionality to run familiar VMware Cloud Foundation technology, including vSphere, HCX, NSX-T, and vSAN. We also heard from our enterprise customers the importance of large scale bulk migration, so to further ease migration efforts, you will now be able to take advantage of HCX Enterprise edition (currently in preview) which includes Replication Assisted vMotion (RAV).

Finally, from our experience with enterprise migrations, we know the importance of planning and estimating your migration to cloud. We are pleased to share that Azure Migrate supports Azure VMware Solution, helping businesses discover all of your VMs running on-premises and create assessments based on sizing and cost analysis, so you can create your Azure VMware Solution private cloud to your needs.

Unmatched cost efficiency with Azure Hybrid Benefit

As a core Azure service, Azure VMware Solution also supports Azure Hybrid Benefits, allowing you to bring your existing Microsoft workloads, running on-premises to the cloud, in the most cost-effective way. You can now maximize the value of existing on-premises Windows Server and SQL Server license investments when migrating or extending to Azure. In addition, Azure VMware Solution customers are also eligible for three years of free Extended Security Updates on 2008 versions of Windows Server and SQL Server. These pricing benefits are only available on Azure and create simplicity and cost efficiency for your journey to cloud.

Seamless access to Azure services

Throughout development, delivering on a seamless connection to Azure services has been paramount. Azure VMware Solution is tightly integrated with the Azure global network backbone to ensure you can centralize all your cloud resources in Azure. Now, whether you are looking to migrate completely or extend your on-premises VMware-based applications, you gain access to Azure services that can enhance security, management, and unlock modernization across your entire environment. We know from our customer conversations that organizations need time to develop cloud competencies within the organization. Azure VMware Solution gets you to the cloud quickly, maintaining consistency in the VMware tools and operations that you have, and growing cloud skills over time.

To help ensure business continuity and improve security and management, Azure VMware Solution customers can incrementally attach Azure services to enhance the existing environment and processes, including:

• Azure Backup combined with the Recovery Services vault for VM backup and recovery. Provides geo-redundant, longer-term, off-site storage for compliance purposes, and, at the same time, address short-term retention needs for restoring data. This is a cost-effective, scalable approach to backup.
• Connect Azure Security Center and Azure Sentinel with Azure VMware Solution virtual machines (VMs) to quickly strengthen your security posture and protect against threats. As security threats continue to increase, this provides a streamlined way to apply advanced best practices to your environment.
• Create efficiencies with enhanced management functionalities to support cloud and hybrid environments. Integration of Azure Monitor for vCenter logs provides visibility for VMs usage; Azure Update Manager for Lifecycle Management of Windows VMs; Azure Traffic Manager to balance application workloads running on Azure VMware Solution across multiple endpoints; Azure App gateway to manage traffic to webapps running on Azure VMware Solution; API Management to publish and protect APIs on Azure VMware Solution VMs for the developer community.
• Optimization storage for VMs running on Azure VMware Solution with integration with Azure NetApp Files and Azure File Share. As you also modernize application storage strategies, you can now also integrate with Azure SQL services.

Expanding partner ecosystem

As you look to move workloads from your current datacenter, and extend existing VMware workloads from on-premises to the cloud, we recognize that confidence in supportability for partner technologies that you may use today is also important. Microsoft is working closely with key partners that are integral to your IT environment, including leading solutions for backup and disaster recovery, as well as other enterprise services that run on-premises today.

“Zerto and Azure have long been an ideal combination for businesses accelerating cloud adoption and looking to simplify data protection and disaster recovery (DR). Now, with Microsoft’s new generally available release of Azure VMware Solution, customers can use Zerto to replicate and protect VMs into the cloud and within the cloud, with the same seamless experience they have on premise. Users can replicate and recover into Azure VMware Solution in under two hours, providing the ability to implement a real-time, enterprise DR solution in less time than it takes to watch a movie. It’s fast, it’s easy to manage, and it’s a great platform for disaster recovery and data protection for hybrid cloud deployments.”

Gil Levonai, CMO and SVP of Product, Zerto

“Partnering with Microsoft Azure enables us to provide a robust and cost-effective solution for disaster recovery and business continuity. It’s an ideal combination: the JetStream DR software brings continuous data protection to enterprise VMware environments, Azure Blob Storage provides a cost effective means of maintaining recovery assets, and the Azure VMware Solution provides a highly available, reliable VMware platform that can scale to meet customers’ recovery and failover requirements.”

Tom Critser, Co-Founder and CEO, Jetstream

“Using Microsoft Azure has been a critical component of the success of Commvault’s solutions and we are happy to add support for Azure VMware Solution as part of a customer’s heterogeneous, enterprise-wide data environment. In leveraging Microsoft’s Azure infrastructure, our joint customers gain the benefits of ease, scalability, security, and cost reduction seamlessly combined with leading features of our products, making it a winning combination for customers.”

Randy De Meno, VP/CTO, Microsoft Products & Solutions, Commvault

“Veritas Technologies and the Microsoft Azure teams are mutually invested in our ongoing partnership to solve the most important customer needs in Azure VMware Solution. We worked very closely together in early testing and certification to deliver a level of protection and recovery that surpasses VMware admin’s expectations in Azure VMware Solution. Veritas data protection solutions ensure that no matter where VM data resides, it meets the enterprise data protection requirements of storage reduction, and automated intelligent policies. Veritas’s continued support for the next version of Azure VMware Solution further illustrates our strong partnership and aligned commitment to helping our joint customers in their ongoing adoption of hybrid cloud, including their VMware estate. VMware admins no longer have to choose between local or hosted when it comes to their workloads and can rest easy knowing their data is protected and recoverable from anywhere, to anywhere with Veritas NetBackup.”

Doug Mathews, VP Product Management, Enterprise Data Protection and Compliance, Veritas

“Veeam currently supports the backup of Azure-native virtual machines via Veeam Backup for Microsoft Azure. Now, Veeam support for Azure VMware Solutions makes it possible to easily backup and replicate vSphere workloads to and from Azure. Through Veeam Availability Suite, simple workload protection and portability is possible across on-premises VMware, Azure VMware Solution, and Azure-native VM workloads. As the leader in Cloud Data Management, Veeam strives to partner with our 375,000 customers and help them achieve their business objectives. Our day one support for Azure VMware Solution is not only a testament to our customer commitment, but also in our investment and strong, long-term relationships with VMware and Microsoft.“

Danny Allan, Chief Technology Officer and SVP of Product Strategy, Veeam

Learn more about Azure VMware Solution

The Fedora Project is pleased to announce the immediate availability of Fedora 33 Beta, the next step towards our planned Fedora 33 release at the end of October.

Download the prerelease from our Get Fedora site:

• Get Fedora 33 Workstation Beta
• Get Fedora 33 Server Beta
• Get Fedora 33 IoT Beta

Or, check out one of our popular variants, including KDE Plasma, Xfce, and other desktop environments, as well as images for ARM devices like the Raspberry Pi 2 and 3:

• Get Fedora 33 Beta Spins
• Get Fedora 33 Beta Labs
• Get Fedora 33 Beta ARM

Beta Release Highlights

BTRFS by default

All of the desktop variants of Fedora 33 Beta – including Fedora Workstation, Fedora KDE, and others – will use BTRFS as the default filesystem. This is a big shift: we’ve been using ext filesystems since Fedora Core 1. BTRFS offers some really compelling features for users, including transparent compression and copy-on-write. For Fedora 33, we’re only defaulting to the basic features of BTRFS, but we’ll build out the default feature set to include more goodies in future releases.

Fedora Workstation

Fedora 33 Workstation Beta includes GNOME 3.38, the newest release of the GNOME desktop environment. It is full of performance enhancements and improvements. GNOME 3.38 now includes a welcome tour after installation to help users learn about all of the great features this desktop environment offers. It also improves screen recording and multi-monitor support. For a full list of GNOME 3.38 highlights, see the release notes.

Fedora 33 Workstation Beta also provides better thermal management and peak performance on Intel CPUs by including thermald in the default install. And because your desktop should be fun to look at as well as easy to use, Fedora 33 Workstation Beta includes animated backgrounds (a time-of-day slideshow with hue changes) by default.

Fedora IoT

With Fedora 33 Beta, Fedora IoT is now an official Fedora Edition. Fedora IoT is geared toward edge devices on a wide variety of hardware platforms. It is based on ostree technology for safe update and rollback. It includes the Platform AbstRaction for SECurity (PARSEC), an open-source initiative to provide a common API to hardware security and cryptographic services in a platform-agnostic way.

Other updates

Fedora 33 Beta defaults to using nano as the editor. nano is a more approachable editor that is more welcoming to new users. Of course, those who want to use vim, emacs, or any other editor are still able to.

Fedora 33 KDE Beta enables earlyOOM by default, as Fedora Workstation did in the previous release. This helps improve system responsiveness on systems that are running out of memory.

Fedora 33 Beta includes updated versions of many popular packages like Ruby, Python, and Perl. .NET Core will now be available on Fedora on aarch64, in addition to x86_64. We’re also dropping a few older versions: Python 2.6 and Python 3.4 are retired. The httpd module mod_php is also dropped, as php-fpm is a more performant and more secure PHP module.

Testing needed

Since this is a Beta release, we expect that you may encounter bugs or missing features. To report issues encountered during testing, contact the Fedora QA team via the mailing list or in the #fedora-qa channel on Freenode IRC. As testing progresses, common issues are tracked on the Common F33 Bugs page.

For tips on reporting a bug effectively, read how to file a bug.

What is the Beta Release?

A Beta release is code-complete and bears a very strong resemblance to the final release. If you take the time to download and try out the Beta, you can check and make sure the things that are important to you are working. Every bug you find and report doesn’t just help you, it improves the experience of millions of Fedora users worldwide! Together, we can make Fedora rock-solid. We have a culture of coordinating new features and pushing fixes upstream as much as we can. Your feedback improves not only Fedora, but Linux and free software as a whole.

More information

For more detailed information about what’s new on Fedora 33 Beta release, you can consult the Fedora 33 Change set. It contains more technical information about the new packages and improvements shipped with this release.

MY.GAMES and Allods Team have announced that Skyforge, a free-to-play MMO, is coming to Nintendo Switch this fall.

The game has players taking on the roles of Immortals, powerful god-like beings destined to save the planet Aelion from invasion. You’ll be journeying through “wondrous worlds inspired by fantasy and science fiction, with hundreds of hours of exciting gameplay, legendary stories, and thrilling battles to discover.”

With Skyforge being a free-to-play title, you won’t need a Nintendo Switch Online subscription to enjoy online play, and further updates are also planned to become available for free at a later date. On top of this, and for a limited time only, players will be able to receive an exclusive in-game gift pack which will give you a helping hand if you’re new to the game.

Here’s a little more on the game itself:

Using incredible Immortal powers, players can switch between 18 unlockable classes as they master an intuitive combat system and harness unique, class-specific abilities. Rock out with the Soundweaver’s killer riffs, shoot to thrill with the Gunner, and set Aelion ablaze with the Firestarter!

Beyond an epic main story, the fight to defend Aelion will continue in free updates that push the boundaries of Skyforge’s constantly-evolving universe. Invasions, regular seasonal events, invite players around the world to unite online in a fight against invaders from across the stars and their avatars of destruction. Soon after the Switch launch, players can purchase an Invasion Pass to earn Invasion-exclusive rewards from battles, including special in-game cosmetics.

We don’t have a specific release date just yet, but expect to see this one popping up on the eShop over the next couple of months.

Have you played the game on other platforms? Will you be giving it a go when it comes to Switch? Tell us below.

<!– –>

<!–

Calendar

View All     Submit Event

---

–>

If you enjoy reading this site, you might also want to check out these UBM Tech sites:

---

---

  

---

The following blog post, unless otherwise noted, was written by a member of Gamasutra’s community.
The thoughts and opinions expressed are those of the writer and not Gamasutra or its parent company.

---

(This article was also posted at https://spacemoguls.com/space-moguls-map-screen-retrospective/)

This is a technical article describing the development of the map screen of Space Moguls for Commodore 64 and published by Protovision. The article is not reasoning why I develop Commodore 64 games, but a technical and design deep dive into the map screen of the title. There are no code snippets in this article.

Space Moguls is a 2018 four player strategy game inspired by M.U.L.E. that was released 35 years earlier in 1983 by Ozark Softscape and published by then just-founded Electronic Arts. Both games are based on taking turns claiming land, generating items and trading between players and the store with the goal of having the most wealth at the end.

To learn more about the game feel free to look over the Player’s Guide here: space-moguls-players-guide

One aspect where Space Moguls differs from M.U.L.E. is the map screen which instead of being two color black on white uses the full 16 color palette the computer is capable of, This was the first system created for the game and contains several features that may not be obvious while playing the game.

The map is procedurally generated at the start of the game, and much of the map is covered in fog so that the final map is not known in the beginning. Since each land cell type produces different amounts of each item type this means players may change their strategy as the game reveals more of the map.

This is how the final map screen looks like during the Production stage, one of the seven stages of each turn:

The end result of the Map Screen during the Production Phase 4 rounds into a game.

Going back to the planning, here is the full on-paper map design of the game. For a short while the town covered three land cells, but as seen above the town sits in land cell #42. This picture was printed on paper and all the subsequent design was based on notes written over it. This is not its final form, but a readable capture from mid-development!

Design notes, this page is the entire documented map design of Space Moguls

One early decision was to use a hex grid for the map. This required some planning for hardware built for 40 by 25 characters of 8 by 8 pixels. In multi-color mode the pixels are also double width, meaning each pair of pixels share the same color.

The first design question was what is the best orientation for the hex grid?

The noticeable difference between A and B in the image above is that the hex cells are larger in A allowing more art detail per cell, but the slanted edges look worse due to the double width pixels. This stage of just drawing different grid layouts and seeing how each compared to the rest took quite a bit of time and these examples are just the most workable ones I came up with.

This choice ended up with B as the winner because I could fit exactly 10 hex cells horizontally on even lines and 9 on odd lines, and 8 rows perfectly filling 40 by 25 character cells! Of course this didn’t leave any room for a game HUD but that’s a different problem that future me will have to deal with.

Commodore 64 multicolor bitmap mode uses 3 out of 16 colors plus a shared background color for each screen character (8×8 pixels). Below is an example of one screen character with the background color black, and custom colors dark gray, mid gray and light gray.

An example of one bitmap character (8×8 pixels with double width to specify multicolor)

The top and bottom of the hex cells the screen characters are shared with neighboring cells. This means those screen characters need to share the same 3 colors + background, which is too restrictive in the source art.

Being able to use all 3 colors for each 8×8 character in the hex cell art helps add color and distinctiveness to each hex cell type so the best solution is to accept drawing cells in overlapping characters with color remapping.

The simplest useful remapping is just counting how many pixels of each color is used in each 8×8 cell (out of 32 double pixels) and pick the 3 most used colors. Pixels with colors that are discarded are replaced by looking up the closest match in a table.

Mixing characters and remapping colors is not a fast rendering approach on a 6502 series CPU running at 1 MHz, but it isn’t unreasonable. Anytime you draw in bitmap mode you’re not updating every frame (unless doing extreme speed-coding!)

But why stop at hex cells with straight edges, since rendering hex cells is so complex anyway? Drawing outside the lines allows for a sense of ground height, like the trees in the forest cell, cactuses in the desert cell or mountain peaks in the mountain cell.

The various types of hex cells in Alia Terra of Space Moguls, from left to right: Plains, Forest, Desert, Mountains, Steppe, Marsh and Lake.

This is what the source art of the desert land type looks like

In the desert cell example above, to the left is the art made up of 4×5 characters (8×8 pixels). The middle white shape is the background mask, these are the parts of the art that are drawn on top of the land cells above. To the right is the overlay mask which represents pixels drawn on top of other cells background and river cells.

The rendering is done one 8×8 screen character at a time so if just part of the land cell needs to redraw only the characters that actually change needs to redraw.

Another early design decision was that a river crosses the map between the top and the bottom. Land cells with a river has a bonus for producing food, but a negative effect for most other kinds of items. The river can be seen both in the map screenshot and the paper design above and rendering the river layer fits easily into rendering the land cell layers. It is nearly essential to capture a good river/plains cell early in the game to have a good supply of food throughout the game.

Each river cell has a background and a draw mask.

There are six sides to each cell which results in 13 combinations of land cell inlet and outlet. The direction of the river doesn’t matter.

For the example below I’m showing a desert cell neighboring a lake cell and with a river running through it. It would be unlikely to appear in the game in this configuration but it is easier to see the river and forest/lake cells being drawn.

A step by step drawing of all the land cell layers except gameplay

The steps represented by the image above are:

1. Draw background bottom parts of the cells above left and above right
2. Draw the cell itself with the background mask
3. Draw the top parts of the cells below left and right with their background mask
4. Draw the river if one intersects the Land Cell
5. Draw the cell itself again with its overdraw mask
6. Draw the top parts of the cells below left and right with their overdraw mask

On top of the map the Installed Droid and production tabs can be drawn.

The final color remapping back to 3 colors + background color for each 8×8 pixel character is not shown here.

As soon as a player claims a Land Cell a house icon using that player’s color is drawn into the cell to mark it as occupied. This happens during the Land Grant or the Land Auction stages, and in rare cases a Global Event can award one player an extra Land Cell.

The icons above represent:

• Unassigned owned land (House)
• Ore mining droid
• Food producing droid (Land)
• Food producing droid (Lake)
• Materials producing droid
• Rare Materials producing droid
• Energy producing droid (Land)
• Energy producing droid (Lake)

There may be strategy games that play well without any text / icons over the game map but not this game. It is vital that after looking away from the screen for a second you can immediately see what is going on when the eyes return to the action.

But apart from the zigzag edge of the map there is no part of the screen space left and drawing text using double wide pixels makes it hard to read.

Conveniently on the Commodore 64 there are top and bottom borders that can be tricked into displaying sprites. Commodore 64 sprites are 24 by 21 pixels so each sprite can display multiple lines of text and placing all eight of them horizontally allows for 192 pixels wide lines which is not bad at all.

And even if you use 8 sprites in a single line you can reuse them as the screen draws which means a fairly large amount of UI is possible by just using sprites. Of course the sprites used for text also need to coexist with the gameplay usage of sprites so some careful planning is needed when placing the information on the screen.

One problem that occurred fairly late in production was learning that NTSC borders are more narrow on normal TVs, guaranteeing only a few pixels on top and as few as 9 pixels below the screen. The solution was to allow larger text for those that play on a better TV and smaller for those on a more limited TV system.

There is only one font so the text scaling was implemented by using a line lookup table and carefully placing horizontal elements of the letters along the most used lines. The font size needs to be set before the game start due to the lack of in-game menus.

Space Moguls main menu, selecting the HUD text size. Text size A is the largest option.

Text size B

Text size C

Text size D

Without an actual map layout to render there isn’t much point to the renderer. Maps are generated randomly to make each play session a little bit unique. The code for generating maps use a lot of weights and rules to make the land feel natural and consistent.

The first step in generation is placing the river starting at cells neighboring the town cell in the center, then walking sideways and upwards/downwards until the top or bottom is met.

After the river is laid out the generator starts with the center land cell occupied by the town and generates a neighbor tile to the town or any previously generated tile until the board is full.

Each cell starts with an array of chance indexed by each type of land and then a land type is picked randomly weighted by the array. The array is filled out based on the occurrence of that land type for the planet, and modified by the neighboring cells and the occurrence of a river in the same cell.

For example, a lake cell is more likely to occur next to other lake cells and on a river. A desert cell is unlikely to occur next to a lake cell and so forth.

Once the map is complete all the cells are covered in fog except the town cell, and a planet specific number of fog cells are cleared up immediately. The rule for clearing fog is that only cell neighboring a cell without fog can be cleared so there can not be isolated holes in the fog.

With a map and the ability to draw it computer controlled players need a way to navigate efficiently. There isn’t anything in Space Moguls that block computer players from always walking in a straight path but certain land types make you move slower and trying to walk through fog is particularly slow.

While pathfinding is almost a non-issue on modern computers trying the same approaches with a much slower CPU and much less RAM is not always productive.

To be fair, A* was originally implemented and works just fine, there is not much else going on while CPU players navigate the map, but it is not as elegant as I wanted it to be.

The definition for “elegant” in this context is entirely personal but with some goals such as:

• Fast but not at the expense of the worst case for an 8-bit CPU
• As static as possible – avoid dynamic lists, no stack based function recursion
• Using a limited and constant amount of RAM
• Ideally re-using memory that is not currently in use

There is no need for decompressing data while pathfinding so a buffer reserved for that purpose can be reused here. In this buffer each land cell is represented by a byte. This byte represents how much “effort” is used to reach that cell from the cell currently occupied by the player.

Initially the buffer is filled with the value 127 unless it is covered by fog which sets it to 255. Fog is significantly slower to walk through so it should never be crossed by a computer player. Finally the value for the cell the player currently occupies is set to zero.

In addition to the map array there is also two arrays of the previous iteration’s added cells so that while traversing one array the other array is populated and the next iteration the arrays are reversed. The player’s current cell is added to the first list.

For each iteration the previously populated list for each cell look at each of its neighbor and if it isn’t traversed yet, add it to the next added list and add the cost of traversing it from the current cell’s cost plus the cost of traversing the new cell.

When the entire map is filled out look at the destination cell, add it to the end of the path and traverse each step to the lowest effort neighbor until the starting point is reached.

This approach is not the fastest but the goal here is to be as consistent as possible while using the least amount of memory. The size of this code is also fairly small.

In any off-earth game I’m personally curious how something approximating earth would look like but also what other planets might be like. Space Moguls contains four different destination planets: Alia Terra (earth-like), Mars, Winternus (earth-like but winter) and finally 46C which is more post modern art inspired than realistic.

Space Moguls is a large game with plenty of systems and the map screen is just one of these systems, but it is something I’ve wanted to share since my early successful experiments. The map screen is also central to the game experience since most turn stages takes place on the map.

The goal with this article is mostly to share a neat implementation of a map screen in a Commodore 64 screen, and to highlight what is possible to do even with limited hardware resources.

On a final note, since I also enjoy making custom tools there is a nearly finished mod tool, but I have no insight into the overlap of modders and retro strategy game enthusiasts. Let me know if there is any interest in something like that.

---

Related Jobs

Disbelief — Cambridge, Massachusetts, United States
[09.24.20]
Programmer

---

<!–

Extra Div –>