• Advertisement
  • entries
  • comments
  • views

About this blog

Following the development of my fighting fantasy inspired RPG

Entries in this blog


Adding the menu, loading screen and mini-map

Hi everyone!

It has been a busy month or so in the land of game development for me. My game has moved on to now having a proper menu system, a loading screen and asynchronous streaming levels. Along with this I have also added a mini-map which uses a second camera directly above the player's skeletal mesh, which follows its position, always 25 metres above the player's head and never rotating, so the mini-map always faces north. The stamina bar has been moved below the mini-map and made smaller. I decided to generally ape the way GTA V does this, as it is likely that players are going to be more accepting of something similar to an existing system, and a UI is a UI, expectations are generally king and doing novel things just tends to pee people off.

Alongside the development of the game, i have spent some time redoing the map of the game world. I have decided that the map will not be 100% accurate, just like most maps in medieval times, it will have flaws. Most of these flaws will be subtle. You can see the new map at the top of this article, to see the old map, you can find it on the website of the web based version of the game in all it's ugly glory.

The menu system of the game is fully 3D, using a seperate level. The game's level structure has been arranged so that the persistent level contains nothing but what is required. Essentially this means it contains nothing but a recast navmesh and a navigation bounds volume. There are two sub-levels which are streamed in and out when required, the first one being the menu map, and the second being the core of the game world proper. Within the game world, various regions are sub-levels of this too, and may be loaded and unloaded via streaming as and when required to save memory.

When the main persistent level loads, it's "On Begin Play" event simply streams in the menu level. While any level is being streamed in, a UMG full screen widget is drawn on the screen which consists of the loading page. The loading page has an animated progress bar/marquee on it to show the player that the game is actually doing something, and hasn't crashed. The menu and game world, in their own "On Begin Play" events hide this UMG widget, revealing the map proper.

It might also not be noticable but i have also turned off "Temporal Anti-Aliasing", a default feature of unreal engine 4 which puts motion blur on everything. For most uses this just makes text above the NPCs heads unreadable and blurs the detail on textures. I have disabled this, replacing it with the more reliable FXAA scheme.

This now actually looks like a proper game, as it doesn't just drop you straight into the game world. There are of course still holes and incomplete bits - clicking "load saved game" does nothing, and dying now fades to black with a message "*** TODO: Reload last save ***". It will be a while yet before this message goes away as save game files are low down on my list of priorities at the moment, next on my list being invetory systems and conversation trees.

For inventory systems i plan to have a simple TList within each thing which may possess items, for example the player, NPCs and treasure chests etc. In the right situation, objects derived from an AInventoryItem actor class may be moved in and out of these lists. Basically, a corpse will be treated as a storage locker It sounds grim, but in my mind, this makes a lot of sense from a program perspective.

As always feedback and comments are welcome below, please let me know if you have any thoughts that might help with my game going forwards



Simple stuff: Creating a spawner in UE4 using C++

Hi everyone!

This weeks simple project was to create an effective enemy spawner in UE4 using C++. I already had a simplistic blueprint version of this, but it had some bugs which were causing crashes in the engine and editor. Once blueprint scripts start crashing the editor, it is hard to troubleshoot the actual cause of the crash, so in these instances i always find C++ easier to debug, having the vast wealth of tools available that are visual studio 2013.

The concept of an enemy spawner is simple. When the player character enters a box defined within the level, one or more enemies spawn at a set location which may or may not be within the confines of that box.

I have decided to share the majority of this class with the community, as i found very little complete code on how to do this, and researching the correct syntax for the SpawnActor() method alone took me a good thirty minutes of googling.

To implement the NPC Spawner, i started out by simply deriving a class from ATriggerBox:
UCLASS()class SEVENSPELLS_API ANPCSpawner : public ATriggerBox{ GENERATED_BODY() bool triggered; /* List of character types to spawn at or near the Spawn Location */ UPROPERTY(EditAnywhere, Category = "Spawner") TArray> CharactersToSpawn; /* Spawn location. If not set, no enemies spawn. */ UPROPERTY(EditAnywhere, Category = "Spawner") class ATargetPoint* SpawnLocation; /* Number of copies of each type of character to spawn */ UPROPERTY(EditAnywhere, Category = "Spawner") int32 Count; /* This value indicates the maximum number of times the spawner will trigger enemies. If zero, the default of 1 is assumed. */ UPROPERTY(EditAnywhere, Category = "Spawner") int32 MaxTriggers; ANPCSpawner(); UFUNCTION() void OnBeginOverlap(AActor* Other, UPrimitiveComponent* Box, int32 OtherBodyIndex, bool bFromSweep, const FHitResult &hitResult); UFUNCTION() void OnEndOverlap(class AActor * OtherActor, class UPrimitiveComponent* OtherComp, int32 OtherBodyIndex);};

The class attaches to two delegates for OnActorBeginOverlap and OnActorEndOverlap. These notify our class when any other actor walks into the edges of our trigger box, and are initialised when the object is constructed:
ANPCSpawner::ANPCSpawner() : triggered(false){ GetCollisionComponent()->OnComponentBeginOverlap.AddDynamic(this, &ANPCSpawner::OnBeginOverlap); GetCollisionComponent()->OnComponentEndOverlap.AddDynamic(this, &ANPCSpawner::OnEndOverlap); if (!MaxTriggers) MaxTriggers = 1;}

Within these two delegate functions, we use the boolean value 'triggered' to ensure that the event may only occur once (for some reason, UE4 sends the begin overlap notification twice for the player character, followed by the end overlap twice), and that we only trigger the event when the player character walks into the trigger area (otherwise, the NPC which is spawned may also create another NPC within the spawn box, and so on, until the system runs out of RAM and crashes!)

Once we have verified that we are triggering in the right situation, we use the SpawnActor method of the UWorld class to spawn the relevant actor objects:
void ANPCSpawner::OnBeginOverlap(AActor* Other, UPrimitiveComponent* Box, int32 OtherBodyIndex, bool bFromSweep, const FHitResult &hitResult){ APlayerCharacter* pc = Cast(Other); if (pc && !triggered && MaxTriggers > 0) { triggered = true; /* Player overlapped the NPC Spawner, spawn the enemies */ FActorSpawnParameters parameters; parameters.Owner = this; parameters.SpawnCollisionHandlingOverride = ESpawnActorCollisionHandlingMethod::AdjustIfPossibleButAlwaysSpawn; for (int i = 0; i actor : CharactersToSpawn) { logprint(actor->GetClass()->GetName()); if (SpawnLocation) { GetWorld()->SpawnActor(actor, SpawnLocation->GetTransform(), parameters); } } } MaxTriggers--; }}void ANPCSpawner::OnEndOverlap(class AActor * OtherActor, class UPrimitiveComponent* OtherComp, int32 OtherBodyIndex){ APlayerCharacter* pc = Cast(OtherActor); if (pc && triggered) { triggered = false; }}

This serves as a great way to test combat, by putting a known trigger box at some point near the player's start point, walking into it to spawn the enemy we want to test:

As always, comments and suggestions are more than welcome!



Rewriting the AI Controller in C++

Hi everyone!

So it's been a while since i last posted a blog entry. It has been an extremely busy time for me, tweaking and improving the performance and design of my game. I have finally moved on from using Blueprint for parts of my game to using C++, where i feel much more at home and it feels more like "proper" programming.

Part of this has been the rewrite of my AI controller, which manages all enemy types which attack the player. The Blueprint version had become a complete spaghetti mess, partly due to the fact that unreal is still new territory to me, and secondly due to the fact that the language is supposed to look a bit like spaghetti to start with, nodes all over the screen connected by linked 'wires'.

I settled upon a finite state machine as my AI implementation. There is a decision tree system already built into unreal engine 4, but implementing my AI using this means treading water in the "GUI-designed-program-code" pool again, so i decided that it would be easier and more readable just to use C++ for it.

This new AI controller is designed to tie in with the new sword-and-shield combat techniques that are now part of the game, as the player is able to dodge, block, and jump as well as backpeddle:

The AI starts out in one of the first two states "Patrol" or "Random Walk" depending on if it has a set of patrol waypoints set up in its properties or not. If it has a set of waypoints (a simple array of ATargetPoint actors) then it will walk around these waypoints in a loop without stopping. If it does not have a set of patrol waypoints, instead it simply walks to random navigable locations within a defined patrol radius:void AGenericAggressiveAI_v2::BeginMoveToNextPatrolPoint(){ if (me) { ATargetPoint* nextwaypoint = me->Waypoints[PatrolIndex++]; MoveToLocation(nextwaypoint->GetActorLocation(), 30.f); if (PatrolIndex == me->Waypoints.Num()) PatrolIndex = 0; }} void AGenericAggressiveAI_v2::BeginMoveToLocation(){ if (me) { MoveToLocation(UNavigationSystem::GetRandomPointInNavigableRadius(this, HomeLocation, me->PatrolRadius), 30.f); }}
The AI character has three movement speeds, starting off in its "Walk" speed (1.0 times the Maximum Walk Rate), then "Jog" speed (1.8 times the maximum walk rate) and finally the "Run" state (2.5 times the maximum walk rate). The AI can decide to walk, jog, or run depending upon what it is doing. Dodging attacks is done at the running speed, whilst trying to get close to the player is done at jogging speed. Patrolling and random movement is always done at normal walking speed.

For simple communication with the rest of the game, there are several delegated events attached to the AI controller:UPROPERTY(BlueprintAssignable) FBeginAttackingPlayerDelegate BeginAttackingPlayer; UPROPERTY(BlueprintAssignable) FStopAttackingPlayerDelegate StopAttackingPlayer; UPROPERTY(BlueprintAssignable) FTriggerAggroDelegate TriggerAggro; UPROPERTY(BlueprintCallable) FPlayerIsAttackingDelegate PlayerIsAttacking;
The BeginAttackingPlayer is called by the AI controller when we are close enough to launch a melee attack against the player. This happens once, then once the attack is complete the AI controller once again tries to get close to the player for another attack, repeating the process until itself or the player is dead.

The TriggerAggro event is called when the AI has spotted the player for the first time. It triggers the aggro sound and animation (character specific) in the character class.

The PlayerIsAttacking event is called by the blueprint portion of the code when the player tries to attack an AI combatant. This is picked up by the AI, and if there is any immediate risk to the AI character (e.g. they are close enough to the player to be harmed) then the AI character will try to backpeddle out of reach of the player, then regroup to try again:void AGenericAggressiveAI_v2::BeginBackOff(){ if (me) { FVector Direction = me->GetActorLocation() - TrackedCharacter->GetActorLocation(); FVector BackOffPosition = TrackedCharacter->GetActorLocation() + 2.5f * Direction; state = SSOD_AGGRESSIVE_STATE_BACKOFF; MoveToLocation(BackOffPosition, 30.f); }} void AGenericAggressiveAI_v2::OnPlayerAttacking(ACharacter* TrackedCharacter){ /* We receive this delegate when the player is executing an attack. * If we are close enough to the player that this might hurt us, * attempt to dodge it - backpeddle immediately. */ if (DistanceFromTrackedPlayer() GetCapsuleComponent()->GetScaledCapsuleRadius() * 20.0f) { me->GetCharacterMovement()->bOrientRotationToMovement = false; me->GetCharacterMovement()->bUseControllerDesiredRotation = true; Run(); StopMovement(); GetWorld()->GetTimerManager().SetTimer(MoveDelay, this, &AGenericAggressiveAI_v2::BeginBackOff, 0.1, false); }}
This provides for a level of intelligence which seems to be quite smart to the player, even though the base rules behind it are quite simple. Compared to the Blueprint based AI, the reactions are smoother, smarter, and more aggressive. Playing against an AI enemy, the results speak for themselves in this video:

Comments and feedback as always are welcome below



Smart enemies and AI

Hi everyone,

I have had some spare time to spend on getting the AI working in my game for enemies. Moving on from simple Chickens, which don't do anything much except walk around waiting to be killed, I have now moved on to getting smarter and meaner creatures to stalk you through the map and make the player's life more akward.

I started out by obtaining two nice models to use as my first two beasties (click the pictures below to enlarge):

These two beasties all inherit from the same 'creature' framework I have created known as "GenericAggressive". The GenericAggressive type is built of two parts, a blueprint AI class, and a blueprint controller class. The controller class is responsible for selecting the correct visual and audio behaviours for the creature, for example the sounds it makes when it sees the player, the animations it uses for spotting, attacking, and chasing the player, and the sounds it makes when it is hurt. These are exposed via parameters to the instance of the object:

The AI class controls the movement behaviour of the creature, e.g. when it is patrolling, when it is chasing the player, when it gives up and how aggressive it is (click the image below to enlarge):

The AI has a few simple "dumb" traits which combine together to give the impression of a much smarter whole:
All GenericAggressive creatures have a default home location, which is set in the constructor of the blueprint to whever it is placed initially in the map.
The creature will patrol at random around its home location, picking random navigable points within that radius to walk to, with a random break of one to three seconds before it picks another route.
Each type of creature has a sight cone, provided by the "AISensing" object, and an auditory sense. Detection of the player by them passing into the sight cone causes the monster to lock onto the player's coordinates and start moving quickly to that location. Simply hearing the player causes the creature to navigate to where it heard the sound, in the hope that during this route it will see the player and be able to chase them proper.
A creature which is chasing the player is then 'locked on' to the player, and will pursue them to within 150% of its patrol radius before giving up, or until the player or the creature are dead.
When a creature locks on to the player, a 'sensed player' animation and sound are played. For example for the cave troll, it roars and raises its weapons in the air ready to charge. These sense animations and sounds serve as warnings to the player of imminent attack.
Any sounds generated by the creature can only be heard within 1000 units of the creature, with the sound volume dropping off linearly along that range.
A creature which is locked onto the player will use the navmesh to attempt to get into range, repeatedly re-calculating its route until it is considered to be within weapons range (at present all creatures have non-projectile weapons such as swords or stingers). Once in weapons range, the creature will attempt to strike if it is within a 90 degree arc facing the player, dealing damage if the player is within the collision capsule of the creature.
Any creature which is close enough to wound the player is also close enough to be wounded by the player and the victor is simply the one who lands the most hits whilst dodging the hits of the other. Each creature can have any number of attack animations, each of which deal different damage amounts and can have any number of attack sounds.
If the player kills the creature, its AI controller is detatched to stop it functioning, and a 'death' animation and sound are played (creature-specific). For example, the scorpion curls into a ball and the cave troll falls backwards and drops its swords.
If the creature kills the player, the player controller is detatched from the player to prevent input to the player character having any effect, the death animation and sound for the player character are played and the level blueprint runs a matinee sequence to fade the screen to black, causing the game to end. Any creatures close by to the player when the player dies will switch to a celebration animation, for example the cave troll waves its swords in the air and cheers. I am hoping to find some creatures that have feeding animations, as this would be a fitting end for any adventure unfortunate enough to die at the claws of those creatures...
If a player manages to get more than 150% of the creatures patrol range away from the creature (calculated as vector length) then the creature simply gives up, and walks back to its spawning point, starting its patrol sequence again. At any point if it sees the player again, it re-initialises the attack sequence.
If there are creatures alive within 1000 units of the player character, the player character switches to his 'nervous' idle animation, which causes him to look around at random and keep his sword close to his chest. At all other times the normal 'idle' animation is used.

Combined together, these rules make for some pretty interesting gameplay, as shown in the animated gif below (which shows me getting my ass handed to me on a plate by my own game... how embarrasing!):

[size=2]A high resolution YouTube version of this, with sound, can be found here.

Ok, i admit it... I purposefully died to demonstrate the health bar and fade to black sequences. (honest!)...

On a related note, now that the screenshots and videos i am putting out there are showing some real action, and not just random wandering across an empty map, i find myself spending more and more time each day on social media drumming up enthusiasm for the game. This is easier than i anticipated as everyone loves a good gif of a fight, so simply recording videos of combat, converting them to gif and putting them on twitter seems to be going a long way in spreading my name around right now. Time will tell!

As always, comments, suggestions, questions are all welcome below!



Winner winner, chicken dinner!

Hi everyone!

As the next step in my game i have decided to anger various right-wing animal rights groups by testing out virtual weapons on virtual chickens. The next step in my game was obvious in that some form of combat was needed.

I have implemented a combat system based on the approximate swing arc of the sword (or whatever weapon the player is weilding) which deals a set amount of damage per swipe, for now. Each chicken or any other NPC listens to the "On Take Any Damage" event which allows it to be hit.


By default, chickens wander in a 100 unit radius of their original spawn location, unless injured, which resets their 'spawn' location and centres their wanderings on a new location. Hitting them also puts them into panic mode which can make them move faster and more often.


Alive chickens emit random clucking sounds every few seconds, and when killed a death animation is played for the static mesh and a death sound played at the same time.

It is rather hard to hit the chickens, as can be seen in the video below:

Questions or comments as always are welcome below!



Swordplay, castles and other RPG things

Hi everyone!

As another week passes it's that time again to showcase what new features i've added to the game.

[/td][td]This week i have concentrated on animations, and using the unreal engine per bone blend along with some alpha blend tricks to allow for a programmable animation of the player character. The player character can at any time either be in the 'scared' state or the 'not scared' state, which affects his idle animation. Whilst 'scared', he looks around in a paranoid way. For now, for testing this is bound to the ALT key. When there are hostile enemies added to the game, being within range of hostile enemies will trigger this paranoid behaviour in the character.[/td][/tr][/table]

[table][tr][td]Left-clicking on the mouse causes the player to swing his sword and attack. This is built from two animations of slashing downwards and across which are blended using a random alpha value, meaning the arms can make a wide variety of diagonal movements. Each slash of the sword generates one of three wooshing sound effects to give the weapon some weight.[/td][td][sharedmedia=gallery:images:6501][/td][/tr][/table]

The UE4 "blend by bone" facility allows me to bind two animations at once to a skeletal mesh, with one animation effecting certain bones in the skeleton, and another animation effecting the rest of the skeleton. For example, the running animation effects the legs and whilst attacking the attack animations effect the body from the waist upwards by specifying the bone named "Spine".

I decided to invest a small amount of money in my game and purchased a very nice castle model, which i am using to good effect within one of the larger cities. This can be seen in the image above, and the video below:

I have also adjusted the speed of the character within its blueprint, so that whilst wading through water the character's travel is significantly slowed, and whilst swinging the sword there is also a (much smaller) slowdown.

There's still a lot more to do, but progress is being made! Stay tuned for further updates...

As always, any feedback, comments, and constructive criticisms are welcome below



Give me my sword, so i might smite thee!

Hi everyone,

The game is now advancing at quite some pace as i find all sorts of things here and there to add, all of which are requirements for gameplay. The main one of these this week has been weapon equip facilities.

The concept of carrying weapons and using them is fundamental to most role playing games. In The Seven Spells Of Destruction, you can carry a limited number of weapons restricted by the size of your backpack and your level (higher level characters find more ingenious ways to stash more items in the same space and have the capability to carry it all).

The first part of this is being able to equip weapons.

[table][tr][td][sharedmedia=gallery:images:6491][/td][td]The character i picked to be my lead hero (which i selected from OpenGameArt) has an axe permenantly attached to his right arm as a secondary element of the skeletal mesh. To work around this and allow selection of other weapons, without altering the model and effectively making my life harder as a non-artist, i simply changed the mesh's material to a transparent one and removed its collision. In short, the player now carries an invisible axe which he swings round to no effect.

To replace the invisible axe i used the construction blueprint for my player character to instantiate the sword (or whatever other weapon he is using) and attach it by the handle to the player's right hand. Due to some animation issues in the model, i have some other blueprint monitoring this to ensure the player never looks like he's stabbing himself.[/td][/tr][/table]

As part of the weapon spawning, i have a scaling factor which specifies the size of the weapon. The use of this is for later in the game's development where a 'grow weapon' spell might be cast making the weapon the player is carrying temporarily (and rediculously) larger.

[table][tr][td][sharedmedia=gallery:images:6495][/td][td]The end effect is a character which hefts a longsword, single handedly too a shown in the GIF on the left.

Along with development of the character and his weapon swinging behaviour, i have added more blueprint-driven systems to the world, such as the ones below:[/td][/tr][/table]


Comments and suggestions are welcome below



Graphical enhancements ahoy!

Another day, another post.

I have now managed to fix the shadows and as part of this have moved on to using full dynamic global illumination. This has allowed me to implement a full day/night cycle.

I am now progressing with adding towns and cities to the map and further amounts of foliage. The video below shows the sunset, moving through the swamp, and around the wall at the edge of one of the larger cities;

In the future i plan to have rope walkways across the deeper sections of swamp to save the character having to walk whilst holding his breath (let's be honest here, you can't swim in armour!) and to improve the swamp foliage, replacing the trees with vines and floating detritus.

Next on my list, importing and creating LOD levels for approximately 100 building models, and associating the correct materials with them...

Comments welcome



Seven Spells of... wha? What's all this rammel?

Hi everyone!

This post earmarks the start of my new journal here on gamedev,net. I tend to start multiple projects at once, so that once i start feeling burnout bite on one, i can change to another and keep up some form of momentum without completely burning out trying to finish just the one project.

To this end, i have decided to rewrite one of my earlier projects, The Seven Spells Of Destruction. This is a role playing game with a very long history which was born in book form when i was thirteen (for reference this is now 21 years ago!).

The first version of this game started out simply as a 'choose your own adventure' style novel, inspired heavily by Steve Jackson and Ian Livingstone's Fighting Fantasy novels. I have always had the urge to create bigger, and better than what is available (otherwise, really, what is the point in doing it?) so to this end i set out to create an adventure with 1480 locations, the books published and available in the shops having usually around 400 locations including the endings.

Creation of this work took approximately a year and a half, and somewhere i still have the handwritten copy of this book, which was written in fountain pen during break time and lunch hours at school and is now barely legible as the ink has started to fade after two decades.

Luckily, long before this was lost forever I purchased my first computer, a BBC Master 128k, and proceeded to type this entire novel into Inter-Word, the only word processor available to me at the time.

Throughout the years, as i got newer more powerful PCs this document was ported and enhanced as it followed me across systems, from Inter-Word to Word 2.0 for Windows 3.1, and then to Office 2000. By the time i was running Office 2000, i was now at university and was 20.

It was at this point i sat down and looked at the document, now able to program for quite some years, and decided that this would be better if it was a game. At the time, web based games were in their infancy and all the rage, so i set out to make the book web-based.

Spending the next year, i created a simple web based engine, which could 'execute' a game-book. To allow this, i split the novel into 1480 files, replacing descriptions of combat/monsters, treasure pickups, paragraph links with an XML-like language. Any tags in the markup were interpeted, updating the character details as required, and anything that was not a tag was simply displayed on the screen. Simple anti-cheat mechanisms were added to prevent teleporting, and i .... promptly shelved this project and got on with others, forgetting all about it until i left uni a couple of years later.

A couple more years rolled by, by this time i was around 25, and decided to bring this project out of mothballs with the intention of making it publically accessible (the version i had written before had only ever ran on my personal Linux machine) and adding lots of extra content.
To achieve this i heavily promoted the game on my IRC network and before long had amassed a small team of about 15 GMs, who busied themselves adding text content, new weapons, encounters, areas, and testing the game.

At its peak, the game had approximately 1500 users and at any time 200-300 of them could be logged in. This was short-lived however as I quickly found that the support time required to support 200-300 active users 24/7 was more than i could offer whilst holding down a paid job, and more than my free volounteer GMs were willing to put in. Basically, i was slowly moving out of the "small game" range and into more "MMO" style territory, without the finances to back it up.

Due to this, again the project stagnated, although again it was programattically complete, playable from start to finish with around 60 hours of gameplay.

Fast-forwarding to the present day, and I often look back at this project through rose-tinted glasses and analyse my mistakes and my successes and have decided to resurrect this project for a third incarnation.

Using unreal engine 4, i intend to re-create this project with a modern engine, and a much more modern look and feel.

The aim of the project is to get all the game's locations and NPCs and plot playable in as short a time as possible, sacrificing graphics and sound at the moment. To compensate for this i intend to use only creative commons and public domain 3D and sound assets from sites such as opengameart for the time being, which so far has allowed me to sclupt the landscape with quite some ease. Compared to writing my code from scratch in C++ and DirectX 11 as i have for Firework Factory, the rate (and graphical quality) of development is nothing short of impressive.

I am intending to keep the game pretty much 100% blueprint based, purely for simple portability reasons. If there is no C++ code to be comped to native code, there should be less issues with portability.

So far, there have been two iterations of the design, as I have left some aspects (such as graphical presentation) rather open ended and fluid. Having an open-ended design has worked quite well at actually producing a finished game in the past two iterations, and having a completed game with a fleshed out world and characters will allow me to quickly create the world in less time.

The game world is rather large, as shown on the (very badly drawn) map from the web based game, below;

I have compressed this map significantly in the UE4 version to fit into a sensible timescale and make it easily navigable by the player. Currently it takes approximately eight minutes to walk end to end of the map, without accounting for any obstacles in the way. I intend to make clecver use of obstacles to make the map harder to navigate in a straight line, hopefully making the map seem much larger than it is. Later in the game fast travel might become a possibility via teleportation spells.

The first screenshot used the Unreal Engine 4 above view template, with point and click to navigate;

I quickly found however that the models available to me did not look as good from this viewpoint, and not having the resources to draw my own, i looked into alternative viewing angles, settling finally on third person view from behind the character;

This version of the game now has the rough outline of the world added to it, which can be navigated by the player character, and has several types of environment including a forest, mountains, rivers, a desert, and a swamp. This video demonstrates travel across my somewhat empty world between the rough centre of the map above, above the mountains but below the swamp, across the north bank of the western river Larret then north into the desert, taking a grand total of 4 minutes 37 seconds in straight lines.

Several things available in the web based version will be dropped from the graphical version for sake of development time and my sanity;
The web based version had several races and professions of character, each affecting the entire game and ending. This will add years to the development time, so will be dropped.
The web based version had simple multi player capaibilities such as chat, P2P combat and P2P pickpocketing. This is going to be dropped as the game will once again be single player only.
Several plot arcs have the ability to re-shape the world (similar to how blowing up Megaton in Fallout 3 levels a town and changes its occupants, the same can happen to a city in the game if you let a certain high level NPC raze it...) This might stay and might not. I am undecided.

Each of these areas has their own ambient sound effects triggered by an ambient audio object. There are a few issues still which i intend to fix, notably:
The dynamic lighting setup is broken horribly, causing the character to have no shadow cast. I think i set the brightness of the skylight too bright and set the wrong colours, washing out the shadows.
The scale of some of the instanced foliage is way out, causing the massive flowers you see in the video.

Once these are fixed i am moving on to adding villages, towns and cities in the correct places, which i have already found creative commons artwork and models for.

I am very aware of the ambitiousness of this project - I have completed this project in several forms and each time it took me over a year. I have no doubt that this third iteration might take even longer still, but the reward and achievement would be more than worth the effort.

Feedback and questions are as always more than welcome!


  • Advertisement