Pariah: Anton – Generated grass biomes [screenshots]

I still didn’t find the time to write the whole progress report about Pariah, but I can say that in the evenings I’ve been practicing pixel art and during the daytime, I’ve been programming! Because Žiga was late with his art work, I’ve imported my own creations to the generator and it produced couple of cool looking grass biomes 😀

 

Huge story teaser

Vegetation is pink because of the Artimoon.

We’ve also had a poll about which style would the players prefer to see in the  released version of the game. Majority of people we asked… where n = 6, 4 said that they prefer the art style on the right (picture below).

Pariah tree art style

 

 

 

 

PS: I’m the author of the style of the “left” tree – which was used in the current biome generation and Žiga modified it to his style on the “right”. I Will show the next screenshots with the modified style as soon as they are available 😀

Till then,  stay pixely and if you’re interested in updates about our upcoming game Pariah, subscribe to our newsletter and check out our social media.

Cheers,

Filip

 

 

art pariah screenshots

Loot drop table implementation in Unity3D (C#)

Many games like Diablo, World of Warcraft and Final Fantasy use loot drop tables for… well… amm… loot drops and stuff 😀

Currently in Pariah I’m facing random generation. Even though it’s gonna be “randomly” generated world, I still want to have some kind of control over the quantity of spawned items, randomly picked backgrounds, vegetation, resources etc.

I’m not saying that the way I’m doing it, is the best way to implement control over randomness, but I found out that using loot drop table (LDT) can really help me out in multiple situations.

Example of usage

For example we can use loot drop tables in biomes when we want to generate ground. Ground can be made out of different tiles, but we still want to pick the tile with the most grass in it and use it more frequently than other tiles… and that’s where we can harness the power of loot drop tables.

We can create a treasure chest script, that has chances of dropping rare, frequent or maybe legendary loot.

We can use loot drop tables for all sorts of stuff. Before diving into the code and further explanation, I’d really recommend reading this awesome article about loot drop tables on Gamasutra.

The case, tutorial and our goal

I know that i’m gonna use loot drop tables multiple times for different scenarios and that’s the reason why I decided to write two simple generic classes that implement basic loot drop tables and loot drop items (LDI) on which we can extend and build more complex systems.

Goal

In Unity we want to have a “GameObject” or a “ScriptableObject” whose script can contain a loot drop table type property. Loot drop table will give us the ability to add items to it’s list, assign item’s probability and randomly pick them based on their weight.

For example, loot drop item can be an enemy that will be spawned in certain area, a rare or a common sword which the player can acquire from treasure chest, an integer which represents the tile id in our tilemap… or whatever we want it to be.

Also we want to have a control over probability of this item being picked by our loot drop table script and here’s the reason we want to assign a weight to each item separately. Weight in our case is nothing else but an integer. Higher the integer, higher the chances of item being picked.

We’re gonna create a “treasure chest” which will “spawn” different items each time we start the game. We will have the ability to assign which item can spawn and what is it’s probability / weight.

About logic in our loot drop table

Our LDT script combines items to a list, ads up items weights and based on weight’s sum, sets the ranges to which the item belongs. LDT script then picks a random number from “0 – sum of all item weights” and based on that randomly selected number, picks the item.

Example

Total weight of 2 items is 120. Weight of first item is 50 and weight of second item is 70. Based on their weights, LDT assigns that the first item belongs to a range 0-50 and the second item belongs to a range 50-120. Based on these numbers, LDT then picks a random number between 0 and 120. If it picked a number which is for example “76”, it means that the second item was picked. Now that we know which item was picked, we can do whatever we want with it.

Unlimited power - loot drop table

For better understanding what’s happening, check out the video above.

So in the end we want to create 2 abstract classes (genericLootDropItem.cs and genericLootDropTable.cs) which can represent different value types. Then we can inherit different variations of LDTs and LDIs by passing them a type. In our case, we’re gonna create an GameObject variation of LDT and LDI.

Because they can represent different values, I saw a solution in using generics. If you aren’t familiar with generics, you can check out this cool tutorial about generics made by Brackeys.

The code

When writing “nested” generic code, the biggest “problem” I’ve encountered was the inablity to assign the items to a LDT via Unity’s inspector. In my understanding the “problem” is that unity can’t serialize generic properties which are multiple level deep.

One of the consequence is that these properties don’t show up in the inspector and we can’t assign them via inspector even if the code is without an error.

My workaround for this problem is that we create an abstract generic class for LDT and LDI from which we inherit other classes based on the type we want to use. This way we “trick” Unity in a way that it show’s up properties in the inspector and we don’t have to write a lot of code over and over again.

GenericLootDropItem script

Let’s start by writing the most basic element of our system, which is a GenericLootDropItem:

  • It holds information about the item it represents.
  • It has weight.
  • For information purposes it displays item’s chance of being picked (in percents).
  • It holds information about the range it belongs to.
using System.Collections;
using System.Collections.Generic;
using UnityEngine;

/// <summary>
/// Item that can be picked by a LootDropTable.
/// </summary>
public abstract class GenericLootDropItem<T>
{   
    // Item it represents - usually GameObject, integer etc...
    public T item;

    // How many units the item takes - more units, higher chance of being picked
    public float probabilityWeight;

    // Displayed only as an information for the designer/programmer. Should not be set manually via inspector!    
    public float probabilityPercent;

    // These values are assigned via LootDropTable script. They represent from which number to which number if selected, the item will be picked.
    [HideInInspector] 
    public float probabilityRangeFrom;
    [HideInInspector] 
    public float probabilityRangeTo;    
}

After we know how our item looks like, we can continue with writing GenericLootDropTable script.

GenericLootDropTable script

It’s the brain of our loot drop table system.

  • Contains a list of LDIs.
  • Holds information about total weight of all LDIs.
  • It has a method which validates all of assigned LDIs (set’s their range from, range to, calculates percents).
  • It also has a method which returns the “randomly” picked LDI from it’s list.
using System.Collections;
using System.Collections.Generic;
using UnityEngine;

/// <summary>
/// Class serves for assigning and picking loot drop items.
/// </summary>
public abstract class GenericLootDropTable<T, U> where T : GenericLootDropItem<U>
 {
	// List where we'll assign the items.
	[SerializeField]	
	public List<T> lootDropItems;

	// Sum of all weights of items.
	float probabilityTotalWeight;

	/// <summary>
	/// Calculates the percentage and asigns the probabilities how many times
	/// the items can be picked. Function used also to validate data when tweaking numbers in editor.
	/// </summary>	
	public void ValidateTable(){	

		// Prevent editor from "crying" when the item list is empty :)
		if(lootDropItems != null && lootDropItems.Count > 0){

			float currentProbabilityWeightMaximum = 0f;

			// Sets the weight ranges of the selected items.
			foreach(T lootDropItem in lootDropItems){

				if(lootDropItem.probabilityWeight < 0f){
					// Prevent usage of negative weight.
					Debug.Log("You can't have negative weight on an item. Reseting item's weight to 0.");
					lootDropItem.probabilityWeight =  0f;
				} else {
					lootDropItem.probabilityRangeFrom = currentProbabilityWeightMaximum;
					currentProbabilityWeightMaximum += lootDropItem.probabilityWeight;	
					lootDropItem.probabilityRangeTo = currentProbabilityWeightMaximum;						
				}

			}

			probabilityTotalWeight = currentProbabilityWeightMaximum;

			// Calculate percentage of item drop select rate.
			foreach(T lootDropItem in lootDropItems){
				lootDropItem.probabilityPercent = ((lootDropItem.probabilityWeight) / probabilityTotalWeight) * 100;
			}

		}		
		
	}

	/// <summary>
	/// Picks and returns the loot drop item based on it's probability.
	/// </summary>
	public T PickLootDropItem(){		

		float pickedNumber = Random.Range(0, probabilityTotalWeight);

		// Find an item whose range contains pickedNumber
		foreach (T lootDropItem in lootDropItems)
		{
			// If the picked number matches the item's range, return item
			if(pickedNumber > lootDropItem.probabilityRangeFrom && pickedNumber < lootDropItem.probabilityRangeTo){
				return lootDropItem;
			}
		}	

		// If item wasn't picked... Notify programmer via console and return the first item from the list
		Debug.LogError("Item couldn't be picked... Be sure that all of your active loot drop tables have assigned at least one item!");
		return lootDropItems[0];
	}

}

You might ask yourself why we’re not inheriting this class from MonoBehaviour and not validating the LDIs in OnValidate method. I’ll explain the reason in the lower section 🙂

Now that we have base generic classes, we can create LDT and LDI for GameObject type.

GenericLootDropItemGameObject script

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

/// <summary>
/// When we're inheriting we have to insert GameObject as a type to GenericLootDropItem
/// </summary>
[System.Serializable]
public class GenericLootDropItemGameObject : GenericLootDropItem<GameObject> {}

GenericLootDropTableGameObject script

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

/// <summary>
/// When inheriting first we have to insert GenericLootDropItemGameObject instead of T and a GameObject instead of U
/// </summary>
[System.Serializable] 
public class GenericLootDropTableGameObject : GenericLootDropTable<GenericLootDropItemGameObject, GameObject>{}

TreasureChest script

It’s the script that represents the treasure chest itself. For the tutorial’s purpose we’re gonna try to keep it as simple as possible. It’s main goal is:

  • When the game starts it picks and generates items from it’s LDT property.
  • Validates LDTs and LDIs.
using System.Collections;
using System.Collections.Generic;
using UnityEngine;

/// <summary>
/// The most simple treasure chest script ever made :P basically on game start it spawns items in a straight line.
/// </summary>
[System.Serializable]
public class TreasureChest : MonoBehaviour {

	// Loot drop table that contains items that can spawn
	public GenericLootDropTableGameObject lootDropTable;
	
    // How many items treasure will spawn
	public int numItemsToDrop;

    // Runs when we start our game
	public void Start(){

		// Spawn objects in a straight line
		DropLootNearChest(numItemsToDrop);

	}
    
    void OnValidate(){

        // Validate table and notify the programmer / designer if something went wrong.
        lootDropTable.ValidateTable();
        
    }

    /// <summary>
    /// Spawning objects in horizontal line
    /// </summary>
    /// <param name="numItemsToDrop"></param>
    void DropLootNearChest(int numItemsToDrop){
        for (int i = 0; i < numItemsToDrop; i++)
        {
            GenericLootDropItemGameObject selectedItem = lootDropTable.PickLootDropItem();
            GameObject selectedItemGameObject = Instantiate(selectedItem.item);
            selectedItemGameObject.transform.position = new Vector2(i/2f, 0f);
        }
    }
}

Because this script unlike GenericLootDropTable inherits from MonoBehaviour, It also has a role for validating LDTs and LDIs. Basically it calls LDT’s ValidateTable method in OnValidate method which validates values as soon as we assign them in the inspector.

The main reason for calling LDT’s ValidateTable method inside the TreasureChest script is that if we inherit the GenericLootDropTable from MonoBehaviour we don’t see LDI’s exposed properties.

If LDT inherits from MonoBehaviour

If GenericLootDropTable inherits from MonoBehaviour

If LDT doesn't inherit from MonoBehaviour

If GenericLootDropTable doesn’t inherit from MonoBehaviour

 

 

 

 

 

 

 

 

Now that we have every script we need, we can easily recreate the demo scene from the video.

Summary

Our loot drop table belongs to more “primitive systems” out there 😀 It can be improved and modified in many ways. Here’s the link to my github repo from where you can easily download unity package and test it out yourself.

What I really like about our simple system is that for an example we could really quickly create LDT and LDI of an integer type and modify our treasure chest script in a way that besides dropping items, it would also drop golden coins or something else.

This is my first tutorial and I hope that some of you will find it helpful. If any of you fellow readers have a suggestion, or have an idea on what I could improve, or if you noticed a bug, please let me know in the comments down below.

Till next time, I wish you happy programming!

Filip

C# loot drop table random generation tutorial unity loot table unity3D

Pariah: Anton – progress report #1

pariah anton devlog 1

“Pariah: Anton” is our next upcoming game. It is going to be a combination of tower defense game and a 2D sidescroller set in an apocalyptic cyberpunk world. The game will have a background story with as little text as possible (Yeah… I’m a fan of Hyper Light Drifter and Kingdom).

Game info

Player’s main mission will be to gather chips, upgrade his base, craft robots, assign them roles, upgrade them, destroy the spawns of hostile creatures (zombies, monsters and probably other god forsaken creatures.) and escape from planet. The game won’t focus as much on player’s main character as on building base and crafting robots. The crafting system will be as simple as possible, but still enjoyable. Each playthrough will be different because the map is always going to be randomly generated.

Release

We are aiming to release the game on a PC in September and when the time is going to be right, we’re gonna try our best to greenlight the game on a Steam market.

Progress

In the last couple of weeks I’ve been thinking about the architecture of the whole game, the player’s movement, which events will be tracked, AI for robots, zombies, monsters etc..

I still don’t have a lot to show you, but till now, I’ve imported a simple sprite (from the asset store) which represents the player (no complicated animations or any other fancy stuff because the main character is still in the drawing board), I’ve imported a sun and a moon drawn by Žiga. The ground is currently decorated with a tileset which will not be used in the final game – we’re aiming for cyberpunk style palette and a little bit simpler shapes.

Player controls

Because the game mainly focuses on the AI of robots and Enemies, the player controls are going to be quite simple. Player is going to be able to walk, dash and use an action button. In video you can see player walking, dashing and dropping chips (without animations :D).

Day and night

Night will stand for terror and will spawn waves of monsters. Day will serve for exploration. I’ll have to figure out which length of day and night will fit the game tempo. We really don’t want player to get bored. That’s why I’m thinking about adding special events which can occur anytime and will lure player to explore the unknown.

Biome generation

World’s will be made out of different “biomes”. Currently we have plan to create biomes for: Base, Grassfield, Forest, Junkyard, Factory. Base will always spawn in the middle of the world and will server as a starting point for our player. Player will be able to expand his base to other biomes. I’ll write more about biomes in the future devlogs. For now I have developed a world generation system which semi-randomly chooses and position biomes in the game.

In video you can see biomes colored for debugging purposes:

  • Base: cyan
  • Grassfield: yellow
  • Forest: green
  • Junkyard: magenta
  • Factory: red

We still have a long way to go to finish our “Pariah”. but then again:

The journey of a thousand miles begins with one step. – Lao Tzu

If you want to stay updated about our progress, subscribe to our newsletter or social networks.

Filip

anton game introduction pariah

Math Panda

Math panda is our first game!

Want to practice math? Let the Math Panda shake your world of mathematical equations. Bring your mathematical skills to next level with this simple game, and try to win all the available abacus as prizes.

Choose between additionsubtractionmultiplication and division, or group them as you wish. Levels suitable for each and every one, for kids to learn, for parents and others to have fun, and for those mathematical enthusiast who just have to break their head on hard calculations.

Features

Compete with others, try to score as high as you can before you are defeated.

  • Range of number from 0-10, 0-100, 0-1000
  • Arrange your own group of mathematical equations
  • Easy level, max speed is locked, suitable for learning purposes
  • Medium and hard level, how fast can you calculate?
  • Hard level, you made a mistake! No second chances for you!

You can get it for free on google play!

educational game kids math Math panda

Beginning of our indie games development journey

I always saw video games as a form of art. To me, video games are one the most powerful mediums to present stories and trigger emotions. I’ll always recall when I got my first console and a game with it. The game was no other than “Super Mario World” which pulled me in the gaming world very, very deep. It just felt awesome when you woke up on the saturday morning, invited your friends to come over and spent the whole day talking and smashing controller’s buttons while playing video games. There wasn’t a week when one of your friends didn’t show you a new trick he pulled out in a game, a new easteregg he discovered or highscore he set.

Anyway… “I grew up”, discovered my passion besides gaming (programming), finished college where I met 3 awesome dudes, found a steady IT job, worked for a while, discovered that I’m not satisfied in my job, quit my job and finally decided that I want to give myself a chance as a freelance web developer or as an indie game developer.

At that time, I realized that this is probably going to be a rare opportunity in a lifetime to fully dedicate my working hours to something that I really want to do. It was a time when a friend (Žiga) called me and proposed a hackaton saturday at his place. I was hyped.

On this little hackaton, we decided to create a simple mobile game, which helps kids to learn Math (Math Panda). We finished the whole project in 2 weeks and published it in a google play store. We were proud.

The whole experience of cooperating in a game development with other friends made me feel awesome. Because of that feeling and a feeling that we can develop games faster and better if we cooperate, I dared to imagine something bigger… I told my friends about the next project… and now here we are for the next 5-6 months, trying to make another game.

The next post will be about the “Pariah: Anton” – our next game. If you want to stay updated about our progress, subscribe to our newsletter in the sidebar.

Pariah: Anton

Filip Djeze Bartus – programming, story

Žiga Koračin – art, graphics

Patrick Andreas Škarjot – music, sfx

Boštjan Gotar – other game

 

beginning game dev hyper fox studios