Elevating Game Development with AI-powered Ideation

Author: Esau Kang

Context

In our most recent Homathon ( hackathon at Homa ), 10 teams utilized generative AI to address various challenges of the game creation process. We created innovative prototypes to enhance workflows for our game developers, our colleagues at our partner studios, and Homa Lab Users in general. This initiative involved the active participation of members from many different teams, providing a space for collaboration and brainstorming. Ultimately, we achieved our goal of exploring the transformative realm of GenAI and its impact on the mobile gaming industry.

Among the various projects showcased, we observed innovative proposals like tools for crafting animated personalized avatars, generating ready-to-use 3D assets, and producing game concepts with inherent hit potential driven by real-time data. This last project has already been deployed-and a huge shoutout goes to our team members Guilherme, Sachin, and Radoslav for being the main contributors to this project, the “Game Idea Generator”.

In this article we will focus on how we built the “Game Idea Generator” that is now in Homa Lab. We will delve into the initial stages of our exploration, the challenges we encountered, and our solutions to those problems. We’ll also share some valuable insights gained during the hackathon and while transitioning these prototypes to production releases on our platform.

Tackling the Ideation process

Starting a project can often be the toughest part, so we aimed to find ways to jumpstart the creative process for both new and experienced game developers.

Our bone to pick with the process boiled down to this:

• Coming up with marketable and clear game ideas is difficult.
• Spotting new trends / finding marketability can be tough.
• Dealing with a lot of data from different places is a challenge.
• Creating a game concept that combines themes, mechanics, and gameplay loops into a fun experience is tricky.
• Documenting an idea thoroughly and clearly, as well as collecting materials for reference, is time consuming and can feel tedious.

Unpacking the Solution

Keeping in mind the challenges game creators face when coming up with ideas that work, we identified a unique opportunity to address these issues utilizing Gen-AI and our data pipeline inside Homa Lab. Here’s how we do it:

Spotting Trends

We use a combination of proprietary data gathering from external sources, including the Android and Apple app stores, on top of our dataset consisting of hundreds of apps tested every quarter. All the data is custom labelled by our AI models (read more about this in our first article ). This combination of varied sources allows us to see both the macro and granular pictures of what is working on the stores at the moment as well as insights into staying power, age, and direction of trends.

Below is a schema of one of the tables we use for this and its associated record count.

create table tbl_store_scraper_apps
(
 s_app_id varchar(256) encode bytedict,
 s_app_name varchar(256) encode bytedict,
 s_app_url varchar(512) encode bytedict,
 s_platform varchar(8) encode bytedict,
 f_original_price numeric(10, 2),
 s_currency_code varchar(3) encode bytedict,
 b_is_free boolean,
 b_is_sale boolean,
 f_sale_price numeric(10, 2),
 dt_sale_end_datetime timestamp encode runlength,
 d_release_date date encode runlength,
 s_developer_id varchar(256) encode bytedict,
 s_developer_name varchar(256) encode bytedict,
 s_developer_url varchar(512) encode bytedict,
 s_developer_internal_id varchar(30) encode bytedict,
 s_developer_email_address varchar(100) encode bytedict,
 s_developer_website_url varchar(100) encode bytedict,
 s_developer_address varchar(500) encode bytedict,
 s_developer_privacy_policy_url varchar(500) encode bytedict,
 s_category_id varchar(30) encode bytedict,
 b_is_category_game boolean,
 b_is_editors_choice boolean,
 i_app_rating_1_star_count bigint,
 i_app_rating_2_star_count bigint,
 i_app_rating_3_star_count bigint,
 i_app_rating_4_star_count bigint,
 i_app_rating_5_star_count bigint,
 i_app_rating_count bigint,
 f_app_rating numeric(7, 6),
 i_reviews_count bigint,
 s_content_rating varchar(100) encode bytedict,
 s_content_rating_description varchar(100) encode bytedict,
 s_description_short varchar(100) encode bytedict,
 s_description_full varchar(5000) encode bytedict,
 i_app_size bigint,
 s_app_version varchar(30) encode bytedict,
 dt_app_update_datetime timestamp encode runlength,
 s_recent_changes varchar(1000) encode bytedict,
 s_min_os_version_text varchar(20) encode bytedict,
 s_min_os_version varchar(20) encode bytedict,
 i_installs bigint,
 i_min_installs bigint,
 b_has_in_app_purchases boolean,
 s_iap_price_range varchar(30) encode bytedict,
 f_iap_price_min numeric(10, 2),
 f_iap_price_max numeric(10, 2),
 s_cover_image_url varchar(512) encode bytedict,
 a_screenshot_url_list varchar(3500) encode bytedict,
 s_video_url varchar(512) encode bytedict,
 s_video_image_url varchar(512) encode bytedict,
 s_header_image_url varchar(512) encode bytedict,
 s_store_country_code varchar(3) encode bytedict,
 s_store_language_code varchar(20) encode bytedict,
 i_screenshot_url_count bigint,
 b_has_subscription boolean,
 i_description_short_length bigint,
 i_description_full_length bigint,
 dt_fetch_datetime timestamp encode runlength,
 d_fetch_date date encode runlength,
 d_reference_date date encode runlength
)

Engaging Players

With our data pipelines that can ascribe labels to the apps we process on the app store and our much deeper insight into our internal set of apps, we know what combinations of game properties work the best.

Finding Marketability

Following a trend is easy, but which are the easiest to follow? Which ones have staying power? Which are the most profitable? We can take advantage of our access to internal data regarding profitability of our currently testing and historically tested games to see behind the curtain and glean hidden insights regarding marketability. Our wealth of data allows us to more successfully detach from any recency or hindsight bias in judgment. Additionally, the internal data unveils market trends and profitability, providing a clear view of what works and what doesn’t.

Idea Fleshing

We’re not done; we still have much to do in fleshing out the idea. We can leverage Gen-AI here to amplify the usefulness of our data and data processes.

To sum up

We have internal information on the best-performing creatives/concepts as well as consolidated labeled data on thousands of public apps. We see what is being tested at the moment by devs who are still in the process of making their games. Therefore, by investigating what works among this cohort and comparing numbers with our expansive records, we have more insight on mobile game trends.

How the Game Idea Generator works in the background:

1. We source our data using two ways.

a. Proprietary data gathering from the Google Play / Apple App Stores / Sensor Tower / Apptweak. We have multiple jobs running on Airflow to scrape every gaming app from top developers since 2019. We then consolidate this data and then categorize and label it. This vast treasure trove of information lets us determine daily granularity about current trends and marketability.

b. Not only do we have data on “post-release” performance, but we also use our proprietary data source of thousands of apps we’re currently testing and have historically tested for unreleased apps. Although this is much smaller, our data here is in much finer resolution. This lets us see the marketability and scalability (profitability) of ideas/concepts directly backed up by our test advertising data. With platform economics, as the platform increases in usage, the data from the platform becomes more valuable.

2. We rank and measure the success of games and have stats describing their marketability/trendiness/profitability as different dimensions to compare.

a. We can weigh specific dimensions and recalculate weights to evaluate current market favorability towards particular aspects of game ideas.

3. The data pipeline’s conclusion is to develop a semi-randomized list of the critical elements that define a game.

4. We take the conclusion of the data pipeline and feed it to our Gen-AI pipeline.

5. We use GPT to expound on the elements outputted and generate a fully fledged game idea with mechanics, theme, and a basic gameplay loop.

6. We use a latent diffusion model to generate reference images from this description and source images from our private test assets or public assets from the app store.

We then expose the steps and processes above to a chat bot that functions as your own personal brainstorming partner. The bot creates ideas from scratch, from a minimal description, or from one of the 2000+ ideas that already exist on our platform. A typical use case is outlined below.

But a project is not successful without learnings. And here are ours:

The key takeaways from this project shed light on the process of integrating AI into the development workflow:

1. Our high-quality data and the insights gleaned from it enables our AI to produce something impactful.
2. AI is used here as an impact multiplier and lets us enhance an existing process to add slices into our vertical integration.
3. The quality of data/tech, and the quality of the data/tech pipeline is still the most critical thing.
4. QA is even more useful in validating (intended) non-deterministic responses.
5. Optimizing performance when using GenAI should not be overlooked, as well as optimizing prompts.
6. Be okay with the unexpected. Utilizing GenAI will produce a lot more unintended results than you may be used to. Be ready to be constantly tweaking and fine-tuning.

Overall, this project and the many other AI tools we’re building aim to empower developers and give them the ability to create, test, and iterate quicker-with more efficiency, and less friction.

Why all game devs should try the “Game Idea Generator”

We’re confident that this tool will assist solo creators and small teams in thinking of novel, marketable game ideas. Some of our favorites generated by the “Game Idea Generator” include a puzzle game with dj and rhythm elements and a side-scroller where the player needs to collect and eat as much junk food as possible.

For people who don’t like the ideation process, you can now turn it into a quick validation process without investing too much time. For people who do, the “Game Idea Generator” still provides a benefit as you get to see another perspective backed up by our data, which could spur other ideas in brainstorming. Think of the this as an extra team member with the sole purpose of aiding in ideation.

Explore the future with Homa’s “Game Idea Generator”, an AI-powered tool for revolutionary game ideas. Immerse yourself in it within Homa Lab today. The horizon of innovation in game development unfolds, guiding creators towards uncharted territories.

If you want to learn more about open positions at Homa, you can visit this page.

Originally published at https://engineering.homagames.com on August 10, 2023.