We've been quiet for a long time! That's mostly because Timefight Zone is taking longer than we expected. It's an incredibly exciting project and we're loving working on it, but our landlords keep telling us about something called "rent" that we're apparently supposed to be paying, so we took a break from the very ambitious Timefight Zone to work on a smaller project that we've been inspired to work on.

That smaller project is Arkshot! A tightly designed first person shooter that takes the frantic fun of old school competitive shooters like Unreal and Quake, and adds a layer of careful stamina and ammo management, as well as our signature projectile avoidance.

It really is a blast to play. It was originally just a fun little project that we made to play with our friends, but we kept having so much fun that we wanted to dedicate a full release worth of work to it to really make it awesome. 

We aren't sure about release dates just yet but it's coming VERY soon. We're continuing to expand our group of playtesters, and if things continue to go as well as they have been we'll be able to set a release date in the coming weeks.

​We're going to be doing a gameplay livestream of Arkshot with a few of our friends tomorrow (March 7th) at 7pm eastern time. Check it out at twitch.tv/codeavarice. Come by, hang out, and ask us questions.

In the mean time, check out this gameplay trailer! Only showing a few of the many powerups and environments that the game has to offer.

We wanted to have the enemies in Timefight Zone sort of “burn” into existence when they spawn, and burn away when they die. We began to look into how to do this, and quickly came across something called a dissolve shader.

We're going to assume you have a basic knowledge of Unity shaders for this tutorial, if you don’t, there are lots of excellent tutorials that can familiarize you with the basics just one Google search away.

So thanks to the Unity wiki page I linked above, we have a dissolve shader to work with. It looks like this:

  Shader "Dissolving" {
    Properties {
      _MainTex ("Texture (RGB)", 2D) = "white" {}
      _SliceGuide ("Slice Guide (RGB)", 2D) = "white" {}
      _SliceAmount ("Slice Amount", Range(0.0, 1.0)) = 0.5
    }
    SubShader {
      Tags { "RenderType" = "Opaque" }
      Cull Off
      CGPROGRAM
      //if you're not planning on using shadows, remove "addshadow" for better performance
      #pragma surface surf Lambert addshadow
      struct Input {
          float2 uv_MainTex;
          float2 uv_SliceGuide;
          float _SliceAmount;
      };
      sampler2D _MainTex;
      sampler2D _SliceGuide;
      float _SliceAmount;
      void surf (Input IN, inout SurfaceOutput o) {
          clip(tex2D (_SliceGuide, IN.uv_SliceGuide).rgb - _SliceAmount);
          o.Albedo = tex2D (_MainTex, IN.uv_MainTex).rgb;
      }
      ENDCG
    } 
    Fallback "Diffuse"
  }

This shader takes a value (_SliceAmount) and a texture (_SliceGuide), and uses a function called clip() to hide any pixels on _SliceGuide who's brightness is less than _SliceAmount.

Below is a gif showing the basic dissolve shader in action. I mapped the same texture to _SliceGuide and _MainTex to better illustrate how the brightness of the pixel in _SliceGuide determines at which point a pixel is hidden.

Note how the darkest pixels are the first to dissolve when dissolving, and the last to re-appear when un-dissolving.

Now for the interesting part, adding the burn effect around the areas that are about to dissolve. If you just want the code, here it is:

    Shader "Dissolving" {
    Properties {
      _MainTex ("Texture (RGB)", 2D) = "white" {}
      _SliceGuide ("Slice Guide (RGB)", 2D) = "white" {}
      _SliceAmount ("Slice Amount", Range(0.0, 1.0)) = 0.5


 _BurnSize ("Burn Size", Range(0.0, 1.0)) = 0.15
 _BurnRamp ("Burn Ramp (RGB)", 2D) = "white" {}
    }
    SubShader {
      Tags { "RenderType" = "Opaque" }
      Cull Off
      CGPROGRAM
      //if you're not planning on using shadows, remove "addshadow" for better performance
      #pragma surface surf Lambert addshadow
      struct Input {
          float2 uv_MainTex;
          float2 uv_SliceGuide;
          float _SliceAmount;
      };


      sampler2D _MainTex;
      sampler2D _SliceGuide;
      float _SliceAmount;
 sampler2D _BurnRamp;
 float _BurnSize;


      void surf (Input IN, inout SurfaceOutput o) {
          clip(tex2D (_SliceGuide, IN.uv_SliceGuide).rgb - _SliceAmount);
          o.Albedo = tex2D (_MainTex, IN.uv_MainTex).rgb;
 
 half test = tex2D (_SliceGuide, IN.uv_MainTex).rgb - _SliceAmount;
 if(test < _BurnSize && _SliceAmount > 0 && _SliceAmount < 1){
   o.Emission = tex2D(_BurnRamp, float2(test *(1/_BurnSize), 0));
 o.Albedo *= o.Emission;
 }
      }
      ENDCG
    } 
    Fallback "Diffuse"
  }


We have added a new value (_BurnSize), and a new texture (_BurnRamp). To recap, we are hiding parts of the model using clip(), which hides the pixel if the value passed into it is less than 0. We subtract _SliceAmount from the RGB value (brightness) of _SliceGuide, so if _SliceAmount is greater than the brightness of the given pixel of _SliceGuide, the pixel is hidden.

To add the burn effect, we again subtract _SliceAmount from the RGB value (brightness) of _SliceGuide, and this time if the resulting value is less than _BurnSize, we choose a pixel on _BurnRamp to color the pixel. This means that we can change _BurnSize to modify how far out from the dissolved area gets a burn effect. The higher _BurnSize is, the farther the burn effect extends.

The pixel on _BurnRamp is chosen based on how far past _BurnSize test is. At 0 you get the far left pixel, and as the value approaches _BurnSize you move farther to the right side of the image. So you're generally going to want to have the bright ember colors on the left, and the dimmer charred colors on the right on your _BurnRamp.

Below is a gif of _BurnSize being modified in real time to illustrate it's effect.

Note how increasing _BurnSize does not effect the areas that are dissolved, it merely changes how large the burned area extends.

That's about it. It's a relatively simple effect to achieve, but surprisingly hard to find concrete information on. Hopefully this post will help a few people add a cool effect to their game.

• The way we are coloring the burnt edges is by setting the emission (o.Emission) to the color of the pixel we chose off _BurnRamp, as well as multiplying the base color (o.Albedo). This will cause the burnt areas to glow in the dark. If you want to achieve an effect with this shader where the edges shouldn't glow, you'll have to change o.Emission, to o.Albedo, and remove the next line down where we multiply o.Albedo by o.Emission.

• Our _BurnRamp is designed for a cartoony art style. If your game has a more realistic art style, you may want a smoother gradient.
• Feel free to use this shader and _BurnRamp in your game. We made this tutorial because we couldn't find any specific information on this type of shader outside paid Unity assets. Hopefully this has been informative, but even if it made absolutely no sense, we'd like for more people to be able to achieve this effect in their games, so just steal our version. :)
  

We're finally back with another Timefight Zone preview video! We got tangled up in some non-Timefight related business for a while, so we didn't have anything to show, but a few weeks ago we dove back in and finally got rid of those placeholder visuals.
Expect another video pretty soon showing off some new and interesting mechanics.

We had to take a break from Timefight Zone for a little bit to work on some other stuff, but we're back and we've got lot's of cool stuff to show off! 

A shop that has jumped straight out of an old silent movie, a new enemy, and lot's of little fun stuff!  

We are in the market for some voice actors to work with us on Timefight Zone. While the game will definitely not be story heavy, levels will be introduced with short cinematics where the main characters need to say things. In order to say things these main characters are gonna need voice actors behind them.

If you have a voice and want it to be in Timefight Zone, drop us a line at admin@codeavarice.com.

Being a game heavily influenced by classic horror movies, the main cast is made up of horror movie cliche characters. They are:

• Blake: Generic jock character. Handsome, fit white dude. Self assumed leader. No real personality traits.
  
• Holly: Generic ditsy slutty girl character. Obsessed with vanity. Not very smart. Obnoxious. Hot. Self centered.
  
• Jared: Token black guy. 
  
• Angel: Goth/emo kid. Doesn't give a shit. Totally deadpan delivery. Basically exists for comic relief.

We're also considering having animated cartoon cut scenes as opposed to doing them in-engine. We think it could add some flavor to the cutscenes that would otherwise be potentially bland.

It's not hugely complex work. All the cool action-y stuff will happen in gameplay, so the cutscenes will just be the characters being a place, the monster shows up, cut to gameplay. Repeat for 10 levels. No more than 10-15 minutes of cutscene work total.

If you are a cartoon artist and want it to work with us on Timefight Zone, drop us a line at admin@codeavarice.com.

Another little update video. This time showing off a new gun, some new mechanics, and enemy turrets!

We've finally got enough content that's more or less presentable to do a quick little showcase video on our next game, Timefight Zone. It's still early days, but we're having a lot of fun working on it. We're planning to do lots of videos like this over the course of development of Timefight Zone, so let us know what you think about the format. We're trying to make the videos informative enough to be interesting for both players and fellow developers, so we'd love to hear from people from both backgrounds to see how we did.

Keep an eye out, we've got some really exciting stuff coming up!