Games [WIP] Raiders of the Lost Island

xelanoimis · Jul 23, 2017

Raiders of the Lost Island is a local co-op party game where up to 4 players compete in looting treasures from a sinking island, while building together a raft to survive the final wave.

DESCRIPTION

Four funny adventurers explore a sinking island under the constant threat of the rising waters. They must work together and collect resources quickly to build a raft and escape before the final wave washes them away. If they fail, they all lose together.

However, the island is full of treasures: gold coins, gems and the most expensive diamonds. This hard to resist temptation will put their friendship to the test, because if they manage to survive, only the richest one will stand in front! The others just helped him win.

Grab your friends and venture to the Lost Island! Seek your fortune, survive together and get rich in the process! Don’t let the greed get the best of you or you will all end up on the bottom of the ocean!

FEATURES

local co-op party game (1-4 players)

lose together, but win alone

beautiful 3d isometric graphics

funny animated characters

basic fighting mechanic

simple controls scheme

gorgeous coins, gems and diamonds

diverse levels with different themes

dangers, traps and hidden passages

rules and environment modifiers

find who your friends really are

tons of laughs and good times

SCREEN SHOTS

AUTHOR

Hi, I'm Alexandru Simion, the main developer of the Raiders of the Lost Island, a project that started with another 3 friends during the Global Game Jam 2017. I'm trying to build up a community of fans for the game so any feedback is welcomed.

http://www.raidersofthelostisland.com/

www.facebook.com/RaidersOfTheLostIsland
twitter.com/xelanoimis
www.youtube.com/channel/UC9DR3SKnlvL720fXvcnfJXA

The game is in ALPHA stage and I'll try to use this thread to post constantly about the technical aspects of the game. So if you're interested, join me and follow the game's development. I'd love to hear from you!

Thank you so much!
Alex

xelanoimis · Jul 23, 2017

So, the first post in this series is about GlobalFog effect.

I'm using the global fog but in my case there were some drawbacks. As you can see the game has an 3D isometric view with a 15 degrees FOV and my camera zooms in and out depending how far the 4 players are spread around the level.

I was using the Distance Fog but I didn't want the players to see the level more foggy when camera was zooming away and less foggy when getting closer (camera moves in/out for zooming).

Even more, I use the Height Fog property to make the water less transparent with the depth level (by constantly changing the height property to match the current water level that goes up and down). This is a gameplay aspect because the water is meant to hide treasures on lower level and challenge the players to remember and plan their strategies accordingly. Obviously I don't want the water transparency to variate with the camera zoom level.

If I simply disable the distance fog, my water won't be opaque enough and the level would be too sharp (I do want just a bit of foggy feel).

The solution was to use a negative value for startDistance which allowed me to disable the Distance Fog and get a similar feeling that stays the same for close and far camera zooming. I had to adjust the script GlobalFog.cs to accept negative values:

Code (CSharp):

// @A: allow negative start distance for fog

// fogMaterial.SetVector ("_DistanceParams", new Vector4 (-Mathf.Max(startDistance,0.0f), excludeDepth, 0, 0));

fogMaterial.SetVector("_DistanceParams", new Vector4(-startDistance, excludeDepth, 0, 0));

Seems to work nicely and here are the results:

You can see the difference between old version A (far) B (near): the underwater details were more visible when camera was close. In the new version the visibility is the same and so is the perceived level of fog over the whole level.

Feel free to comment or post any questions. Any feedback is welcomed!

taistelusopuli · Jul 24, 2017

Such a genius idea for a game! What platforms will you publish on? (Thought I saw XBox controllers in the video)

I assume there will be several islands or will they generated for every new game?

xelanoimis · Jul 24, 2017

Thanks! Now the plan is to release on PC (steam, itch.io) but depending on interest I can see about other options. Yes, there will be more islands, each with random level modifiers for replayability (like shortcuts, stairs, bridges, etc). Alpha demo will come soon, then early access.

Bakuda · Jul 26, 2017

This looks extremely fun! I love co-op games like this. Any chance you'll be releasing a Mac version?

xelanoimis · Jul 27, 2017

Thanks Bakuda! A Mac version is possible, depending on general interest. Unity makes it really easy, though I expect some work is needed, as always is. Fortunately I have a Mac and that should help. Focus is on the development platform which is PC. You can follow the game on Facebook for latest news, but I'll definitely keep track here too.

xelanoimis · Jul 27, 2017

Posted this WIP screenshot with my debug menus on FB and I thought to mention here a few things about the tech, in case someone needs a quick and easy solution.

I have a small wrapper over the Unity old GUILayout. The idea was to easily add new options from different managers, all in the same debug menu (one single OnGUI call). Not the most versatile system, but it takes advantage of the GUILayout. The old Unity GUI doesn't scale with resolutions which may be a problem of accessibility in some cases, but again, this is a quick and dirty debug support.

Here is code, not a state of art, but it has a few tricks:

Code (CSharp):

using System.Collections;

using System.Collections.Generic;

using UnityEngine;

public class DebugMenu : MonoBehaviourSingleton<DebugMenu>

{

public delegate void DebugMenuFunction();

private static int m_frameCount;

private static bool m_active = false;

private static Dictionary<string, bool> m_groups = new Dictionary<string, bool>();

private static List<DebugMenuFunction> m_functions = new List<DebugMenuFunction>();

public GUIStyle m_style;

public GUIStyle m_styleSlider;

public GUIStyle m_styleThumb;

private void Update()

{

if (Input.GetKeyDown(KeyCode.F1))

m_active = !m_active;

}

private void OnGUI()

{

if (m_active)

{

GUI.skin.button = m_style;

GUI.skin.horizontalSlider = m_styleSlider;

GUI.skin.horizontalSliderThumb = m_styleThumb;

GUI.skin.label = m_style;

GUILayout.BeginArea(new Rect(0, 0, Screen.width / 3, Screen.height));

foreach (var f in m_functions)

f();

GUILayout.EndArea();

}

}

// call on Update or LateUpdates

public static void Add(DebugMenuFunction f)

{

if (m_frameCount != Time.frameCount)

{

m_frameCount = Time.frameCount;

m_functions.Clear();

}

m_functions.Add(f);

}

public static bool Open()

{

if (!m_active)

return false;

return true;

}

public static bool Group(string name)

{

bool on = false;

if(!m_groups.TryGetValue(name, out on))

m_groups.Add(name, on);

GUI.color = Color.yellow;

if (GUILayout.Button(name))

{

on = !on;

m_groups[name] = on;

}

GUI.color = Color.white;

return on;

}

public static void Label(string name)

{

GUILayout.Label(name);

}

public static bool Button(string name)

{

return GUILayout.Button(name);

}

public static float Slider(float value, float min, float max, float step)

{

value = GUILayout.HorizontalSlider(value, min, max);

value = min + Mathf.Floor((value - min) / step) * step;

return value;

}

}

It allows me to use it like this in various managers, where needed:

Code (CSharp):

void LateUpdate()

{

DebugMenu.Add(OnDebugMenu);

}

void OnDebugMenu()

{

if (DebugMenu.Group("GAME"))

{

if (DebugMenu.Button("Level " + (m_progression.m_level + 1)))

{

m_progression.m_level = (m_progression.m_level + 1) % Progression.LevelsCount;

}

if (DebugMenu.Button("Finish with success"))

{

PageGame.instance.OnArkFinished();

}

if (DebugMenu.Button("Finish with failure"))

{

PageGame.instance.OnBigWaveFinished();

}

DebugMenu.Label("Final wave time: " + Water.instance.m_finalWaveTime + " min");

Water.instance.m_finalWaveTime = DebugMenu.Slider(Water.instance.m_finalWaveTime, 1.0f, 8.0f, 0.1f);

}

}

xelanoimis · Aug 26, 2017

Saturday Challenge: How many resource sacks can you find in this screenshot?

The sacks must be collected to build the raft, but during last night's playtest, Eddie wanted to see if he can brake the game and work against everyone, hiding sacks or throwing them off the island, so no one would survive. And he succeeded at first, until the rest of us started to work together and watched his every move closely. We didn't get out with much treasure, but we had a story to tell

This unspeakable treason inspired this very challenge. Post a comment below with how many sacks can you spot in this screenshot (excluding the magnified sample sack in the red circle). All are visible, at least a bit.

xelanoimis · Aug 26, 2017

Getting close to release the alpha demo. Last night's playtest revealed a couple of things to be improved.

xelanoimis · Aug 29, 2017

Still iterating on the ending screen sequence.

Here are some movies showing work in progress:
V1

V2

What has been learned (latest playtest and feedback):

1. Showing too much content in a single screen / sequence is confusing for a party game. I have:
- round treasure items (cool to be seen to realize your the result of your effort in that round)
- round points (wealth) got from these treasure items (silver=1, gold=3, diamond=10)
- highlight round winner (spiky badge)
- campaign points (total wealth) summed from each round's points
- cool looking players avatars
- highlight winning player (with most total wealth) by sorting avatars based on their total wealth
- give cool "raider" badge to winning player to enforce it
- show player colors to know who's who (I allow 2 players to take the same avatar)
- chest models that are planned to level up

2. Much confusion about who's who
- players don't care about their colors (not enforced enough)
- players don't like being reordered. They remember their places on the initial choose avatar screen and they know their places on the couch.
- reordering avatars and their scores when someone else gets in front, totally screwed things up. Could improve it up to a point using animated transitions
- will try to focus the winner "in-place", keeping him on his position, but having dedicated cameras and arrangements, win/lose anims

3. Too many numbers at once
- showing both round points and campaign total points... 8 numbers at once was too much for some, trying to disconnect their counting moments.
- also having visual differences between them (some on badges, some on score bar) was also questionable.
- use other measures than numbers (progress bars, etc.) could work

4. Retention for everybody
- find better ways to motivate people to play through the campaign
- if one player is very good and gather lots of treasures, making lots of points each round, other players feel like not standing a chance and may sabotage the campaign, trying to prevent making the boat (hate)
- find ways to allow cooperation in taking him down
- find other ways to motivate (special titles like best builder, maybe fame or xp points gained differently)
- personal tool items will help, but have to see how to give / lose them

5. One saboteur is fun, two might be to much
- if one player tries to prevent the others from building the boat, they have to really work together to take him down
- tried this with 2 against 1 and finally managed to survive

NEXT:
Finish the demo, FAST. I might not include the campaign mode since there area more improvements needed for good retention and motivation. Still one round is fun enough and representative for this gameplay loop.

xelanoimis · Aug 30, 2017

Dev screenshot from an unusual perspective

xelanoimis · Sep 22, 2017

After a some very busy weeks with Dev-Play Conference (won "Best Game of the Show" and "Best Design" awards), showing the game on TV and announcing the public Alpha Demo, I try to get back to work on game's features. Here are a few pictures from the last weeks:

Don't forget to try the Alpha Demo with your friends and tell me about your experience with the game!

http://www.raidersofthelostisland.com/tagged/play

Have fun!

xelanoimis · Oct 29, 2017

Marian is back, working on new levels. So I've implemented a basic HeatMap system to analyze the game flow and to improve the levels. It tracks players movement and it can display multiple sets of data in the editor, for each level. It indicates areas that players don't visit and the paths they prefer. Only local data for now (no online support).

xelanoimis · Oct 29, 2017

Here is the HeatMap source code. Not really polished and by far not optimized. It's more of a debug tool I put together quickly, to cover my current needs. Feel free to draw inspiration and reuse in your projects.

Code (CSharp):

using System.Collections;

using System.Collections.Generic;

using System.IO;

using System.Xml.Serialization;

using UnityEngine;

[System.Serializable]

public struct HeatmapNode

{

public Vector3[] pos;

}

[System.Serializable]

public struct HeatmapQuad

{

public Vector3 pos;

public Vector3 nor;

public int use;

public void Use()

{

use++;

}

}

[System.Serializable]

public class HeatmapFile : StorageData

{

public const int Version = 1;

public int m_version;

public int m_level;

public int m_playersCount;

public float m_sampleFrequency;

public List<HeatmapNode> m_nodes;

public List<HeatmapQuad> m_quads;

public HeatmapFile()

{

m_nodes = new List<HeatmapNode>();

m_quads = new List<HeatmapQuad>();

}

}

public class Heatmap : MonoBehaviourSingleton<Heatmap>

{

public enum Mode

{

Off,

Play,

Record

}

public Mode m_mode;

public float m_playSpeed = 16;

public bool m_drawNodes = false;

public bool m_drawQuads = true;

public Color m_nodesColor = new Color(1.0f, 1.0f, 1.0f, 0.1f);

public Color m_quadsColor = new Color(1.0f, 1.0f, 1.0f, 0.1f);

public float m_quadsAlpha = 1.0f;

public Mesh m_quadMesh;

public Material m_quadMaterial;

private bool m_active;

private float m_timer;

private float m_sampleFrequency = 0.5f;

private List<HeatmapFile> m_files;

private HeatmapFile m_current;

private Dictionary<Vector3, HeatmapQuad> m_quadMap;

public void OnUpdate()

{

if (m_mode == Mode.Play)

{

m_timer += Time.deltaTime * m_playSpeed;

}

else if (m_mode == Mode.Record)

{

m_timer += Time.deltaTime;

if (m_timer > m_sampleFrequency)

{

m_timer -= m_sampleFrequency;

RecordQuad();

RecordNode();

}

}

}

void RecordQuad()

{

for (int i = 0; i < Game.PlayersCount; i++)

{

if (Game.instance.IsPlayerActive(i))

{

Player p = Game.instance.GetPlayer(i);

Vector3 pos = p.transform.position;

pos.x = Mathf.Floor(pos.x / 2) * 2;

//pos.y = Mathf.Floor(pos.y); // / 0.1f) * 0.1f;

pos.z = Mathf.Floor(pos.z / 2) * 2;

int layerMask = 1; // default bit 0

RaycastHit hit;

if (!Physics.Raycast(pos + Vector3.up, Vector3.down, out hit, 2.0f, layerMask))

continue;

pos = hit.point;

pos.x = Mathf.Round(pos.x);

pos.y = Mathf.Floor(pos.y / 0.1f) * 0.1f;

pos.z = Mathf.Round(pos.z);

// Debug.Log(hit.collider.name + " at y=" + hit.point.y + " nor=" + hit.normal + " >> " + pos);

if (m_quadMap.ContainsKey(pos))

{

HeatmapQuad hq = m_quadMap[pos];

hq.use++;

m_quadMap[pos] = hq;

}

else

{

HeatmapQuad qv;

qv.pos = pos;

qv.nor = hit.normal;

qv.use = 1;

m_quadMap[pos] = qv;

}

}

}

}

void RecordNode()

{

HeatmapNode s;

s.pos = new Vector3[4];

int pi = 0;

for (int i = 0; i < Game.PlayersCount; i++)

{

if (Game.instance.IsPlayerActive(i))

{

Player p = Game.instance.GetPlayer(i);

s.pos[pi] = p.transform.position;

pi++;

}

}

m_current.m_nodes.Add(s);

}

void OnDrawGizmos()

{

if (m_active && m_mode == Mode.Play && m_files!=null)

{

if (m_drawNodes)

DrawNodes();

if (m_drawQuads)

DrawQuads();

}

}

void DrawNodes()

{

int t = Mathf.RoundToInt(m_timer / m_sampleFrequency);

for (int i = 0; i < t; i++)

{

foreach (var f in m_files)

{

if (i < f.m_nodes.Count && i > 0)

{

for (int p = 0; p < Game.PlayersCount; p++)

{

Vector3 b = f.m_nodes[i].pos[p] + Vector3.up * 0.25f;

Vector3 a = f.m_nodes[i - 1].pos[p] + Vector3.up * 0.25f;

if ((b - a).magnitude < 4)

Debug.DrawLine(a, b, m_nodesColor);

}

}

}

}

}

void DrawQuads()

{

m_quadMaterial.enableInstancing = true;

foreach (var f in m_files)

{

foreach (var q in f.m_quads)

{

Color c = m_quadsColor;

c.a *= (float)q.use / m_quadsAlpha;

Quaternion rot = Quaternion.FromToRotation(Vector3.up, q.nor);

//Gizmos.color = c;

//Gizmos.DrawMesh(m_quadMesh, q.pos + Vector3.up * 0.15f, rot, new Vector3(2.0f, 1.0f, 2.0f));

Matrix4x4 mat = Matrix4x4.TRS(q.pos + Vector3.up * 0.15f, rot, new Vector3(2.0f, 1.0f, 2.0f));

m_quadMaterial.color = c;

m_quadMaterial.SetPass(0);

Graphics.DrawMeshNow(m_quadMesh, mat, 0);

}

}

}

public void OnStartLevelSession()

{

m_active = true;

m_timer = 0.0f;

if (m_mode == Mode.Play)

{

LoadAll(Game.instance.m_progression.m_level + 1);

}

else if (m_mode == Mode.Record)

{

m_current = new HeatmapFile();

m_quadMap = new Dictionary<Vector3, HeatmapQuad>();

}

}

public void OnEndLevelSession()

{

m_active = false;

if (m_mode == Mode.Record)

{

Save(Game.instance.m_progression.m_level + 1);

}

// clean

m_files = null;

m_current = null;

m_quadMap = null;

}

void Save(int level)

{

m_current.m_version = HeatmapFile.Version;

m_current.m_level = level;

m_current.m_playersCount = Game.instance.GetActivePlayersCount();

m_current.m_sampleFrequency = m_sampleFrequency;

foreach (var q in m_quadMap)

m_current.m_quads.Add(q.Value);

string date = System.DateTime.Now.ToString("yyMMdd_hhmmss");

string folder = "Heatmap/Level" + level.ToString("00");

Storage.Save<HeatmapFile>(ref m_current, (folder + "/heatmap_" + date + ".hmp"));

Debug.Log("Saved heatmap.");

}

void LoadAll(int level)

{

m_files = new List<HeatmapFile>();

string[] files = Directory.GetFiles(Application.persistentDataPath + "/Heatmap/Level" + level.ToString("00"));

foreach(var f in files)

{

string f2 = f.Replace('\\', '/');

f2 = f2.Replace(Application.persistentDataPath + "/", "");

HeatmapFile hf = new HeatmapFile();

if (Storage.Load<HeatmapFile>(ref hf, f2))

{

if (hf.m_version == HeatmapFile.Version)

m_files.Add(hf);

else

Debug.Log("Heatmap old version " + f);

}

}

Debug.Log("Loaded " + m_files.Count + " heatmaps.");

}

}

And you will also need this storage utility class which I also use to store config settings.

Code (CSharp):

/////////////////////////////////////////////////////////////////////////////////////////////////

// GF - Storage

// Game data storage

// Use:

// - have the YourGameDataStructure class serializable ([System.Serializable]) and derived from StrageData

// - implement override YourGameDataStructure.IsValid for versioning or validation

// - call Storage.SaveSlot<YourGameDataStructure>(ref m_gameData, slot)

// - call Storage.LoadSlot<YourGameDataStructure>(ref m_gameData, slot)

// References:

// http://wiki.unity3d.com/index.php?title=Saving_and_Loading_Data:_XmlSerializer

/////////////////////////////////////////////////////////////////////////////////////////////////

using UnityEngine;

using System.Collections;

using System.Collections.Generic;

using System.Runtime.Serialization.Formatters.Binary;

using System.IO;

using System.Xml.Serialization;

[System.Serializable]

public class StorageData

{

public virtual bool IsValid() { return true; }

}

public class Storage

{

public static bool SaveSlot<T>(ref T data, int slot) where T : StorageData

{

return Save(ref data, "savedgame" + slot + ".sav");

}

public static bool LoadSlot<T>(ref T data, int slot) where T : StorageData

{

return Load(ref data, "savedgame" + slot + ".sav");

}

public static bool Save<T>(ref T data, string fileName) where T : StorageData

{

bool ok = false;

string pathName = Application.persistentDataPath + "/" + fileName;

System.IO.Directory.CreateDirectory(System.IO.Path.GetDirectoryName(pathName));

FileStream file = File.Create(pathName);

if(file != null)

{

ok = true;

try

{

// BinaryFormatter serializer = new BinaryFormatter();

XmlSerializer serializer = new XmlSerializer(typeof(T));

serializer.Serialize(file, data);

// Debug.Log("save successful");

}

catch(System.Exception e)

{

Debug.Log("SAVE to file '" + pathName + "' FAILED with EXCEPTION: " + e);

ok = false;

}

file.Close();

}

return ok;

}

public static bool Load<T>(ref T data, string fileName) where T : StorageData /* , new() */

{

bool ok = false;

string pathName = Application.persistentDataPath + "/" + fileName;

if(File.Exists(pathName))

{

FileStream file = File.Open(pathName, FileMode.Open);

if(file != null)

{

try

{

// BinaryFormatter serializer = new BinaryFormatter();

XmlSerializer serializer = new XmlSerializer(typeof(T));

data = (T)serializer.Deserialize(file);

ok = (data != null) && data.IsValid();

}

catch(System.Exception e)

{

Debug.Log("LOAD from file '" + pathName + "' FAILED with EXCEPTION: " + e);

}

file.Close();

}

}

// @NOTE: optional re-construct

//if(!ok)

// data = new T();

// data = default(T);

return ok;

}

public static bool LoadFromText<T>(ref T data, string text) where T : StorageData /* , new() */

{

bool ok = false;

StringReader stream = new StringReader(text);

try

{

var serializer = new XmlSerializer(typeof(T));

data = (T)serializer.Deserialize(stream);

ok = (data != null) && data.IsValid();

}

catch(System.Exception e)

{

Debug.Log("LOAD from text '" + text + "' FAILED with EXCEPTION: " + e);

}

// @NOTE: optional re-construct

//if(!ok)

// data = new T();

// data = default(T);

return ok;

}

}

Search Unity

Unity ID

Useful Searches

Games [WIP] Raiders of the Lost Island