Blogs

Our community blogs

  1. Josh
    Latest Entry

    By Josh,

    Three years ago I realized we could safely distribute Lua script-based games on Steam Workshop without the need for a binary executable.  At the time this was quite extraordinary.
    http://www.develop-online.net/news/update-leadwerks-workshop-suggests-devs-can-circumvent-greenlight-and-publish-games-straight-to-steam/0194370

    Leadwerks Game Launcher was born.  My idea was that we could get increased exposure for your games by putting free demos and works in progress on Steam.  At the same time, I thought gamers would enjoy being able to try free indie games without the possibility of getting viruses.  Since then there have been some changes in the market.

    • Anyone can publish a game to Steam for $100.
    • Services like itch.io and GameJolt have become very popular, despite the dangers of malware.

    Most importantly, the numbers we see on the Game Launcher just aren't very high.  My own little game Asteroids3D is set up so the user automatically subscribes to it when the launcher starts.  Since March 2015 it has only gained 12,000 subscribers, and numbers of players for other games are much lower.  On the other hand, a simple game that was hosted on our own website a few years back called "Furious Frank" got 22,000 downloads.  That number could be much higher today if we had left it up.

    So it appears that Steam is good for selling products, but it is a lousy way to distribute free games.  In fact, I regularly sell more copies of Leadwerks Game Engine than I can give away free copies of Leadwerks Game Launcher.

    This isn't to say Game Launcher was a failure.  In many cases, developers reported getting download counts as high or higher than IndieDB, GameJolt, and itch.io.  This shows that the Leadwerks brand can be used to drive traffic to your games.

    On a technical level, the stability of Leadwerks Game Engine 4 means that I have been able to upgrade the executable and for the most part games seamlessly work with newer versions of the engine.  However, there are occasional problems and it is a shame to see a good game stop working.  The Game Launcher UI could stand to see some improvement, but I'm not sure it's worth putting a lot of effort into it when the number of installs is relatively low.

    Of course not all Leadwerks games are written in Lua.  Evayr has some amazing free C++ games he created, and we have several commercial products that are live right now, but our website isn't doing much to promote them.  Focusing on distribution through the Game Launcher left out some important titles and split the community.

    Finally, technological advancements have been made that make it easier for me to host large amounts of data on our site.  We are now hooking into Amazon S3 for user-uploaded file storage.  My bill last month was less than $4.00.

    A New Direction

    It is for these reasons I have decided to focus on refreshing our games database and hosting games on our own website.  You can see my work in progress here.
    https://www.leadwerks.com/games

    The system is being redesigned with some obvious inspiration from itch.io and the following values in mind:

    • First and foremost, it needs to look good.
    • Highly customizable game page.
    • Clear call to action.

    There are two possible reasons to post your game on our site.  Either you want to drive traffic to your website or store page, or you want to get more downloads of your game.  Therefore each page has very prominent buttons on the top right to do exactly this.

    Each game page is skinnable with many options.  The default appearance is sleek and dark.

    Image6.thumb.jpg.29bc76364b7e74d307fd5dc5177f0411.jpg

    You can get pretty fancy with your customizations.

    Image5.thumb.jpg.09565a53730acbeb44b1f9bd561a13d5.jpg

    Next Steps

    The templates still need a lot of work, but it is 80% done.  You can begin playing around with the options and editing your page to your liking.  Comments are not shown on the page yet, as the default skin has to be overridden to match your page style, but they will be.

    You can also post your Game Launcher games here by following these steps:

    • Find your game's file ID in the workshop.  For example if the URL is "http://steamcommunity.com/sharedfiles/filedetails/?id=405800821" then the file ID is "405800821".
    • Subscribe to your item, start Steam, and navigate to the folder where Game Launcher Workshop items are stored:
      C:\Program Files (x86)\Steam\steamapps\workshop\content\355500
    • If your item is downloaded there will be a subfolder with the file ID:
      C:\Program Files (x86)\Steam\steamapps\workshop\content\355500\405800821
    • Copy whatever file is found in that folder into a new folder on your desktop.  The file might be named "data.zip" or it could be named something like "713031292550146077_legacy.bin".  Rename the file "data.zip" if it is.
    • Copy the game launcher game files located here into the same folder on your desktop:
      C:\Program Files (x86)\Steam\steamapps\common\Leadwerks Game Launcher\Game
    • When you double-click "game.exe" (or just "game" on Linux) your game should now run.  Rename the executable to your game's name, including the Linux executable if you want to support Linux.
    • Now zip up the entire contents of that folder and upload it on the site here.

    You can also select older versions of Game Launcher in the Steam app properties if you want to distribute your game with an older executable.

    Save the Games

    There are some really great little games that have resulted from the game tournaments over the years, but unfortunately many of the download links in the database lead to dead links in DropBox and Google Drive accounts.  It is my hope that the community can work together to preserve all these fantastic gems and get them permanently uploaded to our S3 storage system, where they will be saved forever for future players to enjoy.

    If you have an existing game, please take a look at your page and make sure it looks right.

    • Make any customizations you want for the page appearance.
    • Clean up formatting errors like double line breaks, missing images, or dead links.
    • Screenshots should go in the screenshot field, videos should go in the video field, and downloads should go in the downloads field.

    Some of the really old stuff can still be grabbed off our Google drive here.

    I appreciate the community's patience in working with me to try the idea of Game Launcher, but our results clearly indicate that a zip download directly from our website will get the most installs and is easiest for everyone.

  2. I recently published the full source code to my little mini-game "Asteroids3D". You can download it here:

    Turning this into a VR game with Leadwerks Engine 4.5 was very easy.  I will show you how here.

    The first step is to enable VR.  This code will check to see if OpenVR initializes correctly. If it fails for any reason, an error message will be printed and the game will exit:

    if VR:Enable()==false then
    	System:Print("VR failed to initialize.")
    	return
    end

    Now we need to adjust some settings.  If you are converting an existing game into a VR game, you will probably use seated tracking space. This allows the player to sit and use the keyboard and mouse just like they would in the non-VR game:

    VR:SetTrackingSpace(VR.Seated)

    With seated VR mode the camera offset (your body's position and rotation) is automatically added to the camera when rendering, so there's nothing else to worry about.

    After the map loads, right before your main loop starts, you should add a command to recenter the headset tracking.  I added a five second delay beforehand to make sure the user has time to adjust their headset:

    Time:Delay(5000)
    VR:CenterTracking()

    If you want to mirror the display to the window, you can call VR:MirrorDisplay() right before Context:Sync().  (If you don't want this feature you can actually just remove the Sync() call completely):

    VR:MirrorDisplay(context)
    context:Sync(false)

    Sync will always disable VSync on the window when VR mode is enabled, since the headset refreshes at a higher rate than your monitor, and we don't want anything slowing it down.

    The rest of your game will work just as it would normally. That's really all there is to creating a seated VR game! You can download the VR project here.

     

  3. Hi guys,

    this time I have something special for you. A video containing some real "ingame" footage, so you can finally see how the things, I am writing and talking about, actually look like. This is also the last blog entry for this devblog. Find out more by watching the video. Enjoy it and of course tell me your thoughts!

    For those of you, now wondering, if the Framework will ever be available for public, or what will happen with it, I first recommend you reading my last blog entry. There you can see, whats happening, actually is not to far away from, what the actual plan was. I am just cutting off some features, focusing on the strengths of the framework (which are first person, rpg like games) and just start creating a game with it, to test it in practice, as explained in the said blog post.

    So to nail it down, this means, if the Framework success in delivering an cool tool for creating my game and I can see value for others in it, I will come back thinking about publishing it and I actually see no reason, the Framework should fail :).

     

    Game Dev Tip #4:

    Regarding what I said in the video, I give you the advice to take a close look on what you are doing at the moment. Keep in mind how important it is to focus on the essential things. Focus on what you are best in, not on fixing what you are bad in.

    Do your projects go in the direction you want them to go? Really sit down, take your time and seriously think about it. It can be amazing what results you can get afterwards. The Game Dev Tip series will most likely continue as the new blog starts.

     

    Stay cool and be excited!

    Markus from Phodex

  4. Hi,

    Hello everybody,

    here is a little blogg.

    Due to some feedback, I'm thinking about how a better HUD could look like. Below is the Old HUD, and then the new HUD. What do you think? Or how can a HUD look more appealing to this game?


     

    20170819151915_1.jpg

    20171119170611_1.jpg

  5. There is a problem with the default TextArea.lua widget script.
    Your game will crash when you click on an empty TextArea.

    Fix:
    look for the Function "Script:GetCaretCoord(caret)"
    after:

    local text = self.lines[self.currentline]--self.widget:GetText()

    add:

    if text == nil then return 0 end

     

     

    More will be added when/if discovered...

  6. Hello Leadwerks Forum its me again. The guy who releases too early

    Theres going to be a new game inspired by the Polybius pasta in the player soon. I just wanted to explain the core mechanics of the game and why it is more important than my free time. For some time, I have developed games on other Engines but the tournament got me back to my haven again ,where I am the most confident with my skills. This is why I can try new or more absurd game Ideas like an "intense psychoactive and addictive" effect provoking retro game. But with less focus on the "psycho" and more on the caffeine effect :D. Of course I run into problems because leadwerks is not made for this wireframe look or twodimensional games, so I dropped it already :(... Just kidding, (no really I did but troughout the day more fixes came to my mind) - like using transparent images for rendering them instead of trying to make a skybox background which itself is also wire... you get the idea.

    59e0fc1da32aa_giphy(1).gif.0ba2fcd3fab046c461757a3b5e4bf731.gif

    THE GAME !:

    The game is split into multiple minigames.All have the feeling of an arcade or retro game from the 80's , but who am I to know how they really were like :). For example, if you "loose" at one of these, it automatically switches to the next endless minigame which gets harder and harder with more movement and colors. One of these games, which will hopefully playable at the end of the tournament is almost done to its core. Its an wormhole simulator in which the player travels with a spaceship and needs to gather blue cristals which differ from other objects that you are not allowed to hit: (outdated)

    9F442C6E36C3D82450A949988A8D434FFF524E09

     

  7. Hi, I have made a new list of weapons that will be added in the next version of the game. This list includes the following:

    • AK47
    • AKSU
    • DRAGUNOV
    • F1 GRENADE
    • M-18 SMOKE GRENADE
    • KABAR
    • LAW
    • M9
    • M16A2
    • M82
    • M249
    • M1911
    • MAKAROV
    • MP5
    • RPG
    • RPK
    • TT PISTOL

    The list is based on the Desert Storm wiki found here: https://en.wikipedia.org/wiki/List_of_Gulf_War_military_equipment

    I've added the models for each weapon in game. The weapons will be available in the upcoming version (0.2d).

    euGpaaC.jpg

    I will continue to make progress despite tight schedules (my study in the University is taking my attention away from programming momentarily).

    This is a new loading screen artwork I created several days ago, I will make more of these in the future. The idea is to alternate the artwork that gets displayed in the loading screen.

    loading.jpg

    Thanks for reading. It's a short update. 0.2d will be released soon.

    If you want to keep up-to-date with the development, you can join my Discord here: https://discord.gg/jbvR3zB where I post the latest snapshots of the project.

    ~Jen

  8. Playing with fractals ideas, I obtain this, just look until the end !

     

     

    Here more space game art:

    20170910234350_1.thumb.jpg.717eb421d41d498132c753811ff0095e.jpg

    20170910234404_1.thumb.jpg.d915cf8635c583bed417518f82a35351.jpg

    20170910234434_1.thumb.jpg.0a2489bb2ba41541f1cc4ca6410516fd.jpg

    20170910235927_1.thumb.jpg.ae439fe9ded6e5f6beb97cbb3444d396.jpg

    20170910235940_1.thumb.jpg.8655cd1aed5cb17a5de30d81ef91a635.jpg

    20170910235944_1.thumb.jpg.4ba7d7ccd5ddd82e11b8bd2818eee366.jpg

    20170910235953_1.thumb.jpg.6f38fb3a0b92ec925bef597ce4707dd8.jpg

     

    hope you enjoyed!

  9. Restarted my networking framework yet again. This time I gave it a new name 'Hexe'. The old name was 'Overwatch'. It was named long before the Overwatch game came out. It was based off the Half-Life Overwatch. It oversaw the players, ai spawning, contained a secondary path-finding system, but had no networking as it was not native to the LUA side of Leadwerks. 'Hexe' is German for 'witch'. I don't really know why I chose the name but I have the feeling I will be able to put it to good use. Maybe I'll even mix in some Anglish into it.

    This restart occurred because the framework became too cumbersome. I had the entity synchronization working correctly, but it did not differentiate between player and an object in the world. That wasn't really that bad, what made messed it up was that a lobby system and teams were needed and there was no space to squeeze any other components into the mix.

     This rewrite will focus on the player/client and foremost. The components that are currently being written or are complete are:

    • The server browser.
      • This was a side project created out of necessity. I did not want to have to hard code the ip every time.
      • Anytime I wanted to test multiple clients I had to change the code depending on which computer was running the server. 
      •  PITFALL: Since Leadwerks does not expose the servers local ip address via code, you will need to get it manually from you computer, or use some creative workarounds
    • Network Manager
      • Hexe is split up between a server class and a client class. Both classes use a network manager class that can automatically handle hosting or connecting to a server. The network manager currently handles the handshake and the beginnings of the lobby system.
      • When a client joins it initiates and handles the handshake between the server and client. It also raises events so the server or client can react accordingly if need be. After the handshake is completed, the network manager starts the lobby system
    • The connection handshake.
      • This is was saved from the last version. It makes sure the server and client are using the same protocol version. It will then register the client on the server and give it an incremental number (similar to the source engine) that allows the client state to be manipulated    
    • The Lobbying system:
      • This is completely new. After the handshake is complete, it will send a command launching the lobbying system. The network manager only makes sure that a client is in the servers lobby and nothing more. The client and server manually handle the team creation and player switching on their own.
      •  Teams are not part of the network manager because it would require large amounts of rewrites depending on the type of game being created.

    When the lobbying system is complete the client input will be added. So far things are going well and maybe soon I wont be staring at console output for feedback.
     

  10. This is a simple prototype of what will be the entrance to the underground pipeline. The idea was to test things, such as getting more familiar with the construction of infrastructures in the Leadwerks engine.

    I have to say that this is what seems to me most tedious, moving cubes, scaling them, copying them, putting textures etc etc. And it is when I understand that a game, can not do a single person, if not an equpo of people each with their specific task. So I will go into polishing details of this prototype model.

    Test.thumb.jpg.1ff71ff7bf39ca33c6907fbc9f15bd34.jpg

  11. GorzenDev
    Latest Entry

    Finished and added Field functionality meaning its now possible to set the Fields for each widget.
    for example the style for a button (Push,Link,Checkbox), or backgroundcolor for panels etc.

    below is a screenshot of the fields in action
    guieditor_prev4.thumb.JPG.b6841efab04c2ef17284105bf42ed76a.JPG

     

    Next will be finishing support for custom widgets which i already started on as you can see in the screenshot above(colorlabel).

    At the moment the way to add your custom widgets is a 3 step process.


    First step is adding the widget name to the config.ini like

    [DefineTypes]
    CustomTypeCount=2
    name_0=ColorLabel
    name_1=MultiListView


    Next is adding a type_file with content like so

    [Base]
    name=ColorLabel
    ;allow other widgets to use this as a parent
    allowparent=false
    ;allow addItem
    islistType=false
    ;location of the widget script in your leadwerks project - only used while exporting
    wScript=Scripts/GUI/ColorLabel.lua
    ;location of the widget script for this editor
    eScript=ElementTypes/Custom/Editor/editorColorLabel.lua
    ;default size
    defWidth=80
    defHeight=20
    ;amount of 'extras' defined
    dCount=6
    [Define_0]
    name=align
    type=String
    [Define_1]
    name=valign
    type=String
    [Define_2]
    name=wordwrap
    type=Bool
    [Define_3]
    name=border
    type=Bool
    [Define_4]
    name=bordercolor
    type=Vec4
    [Define_5]
    name=textcolor
    type=Vec4


    And last but not least you need to edit a copy of your script and disable any EventQueue::Emit events,
    and add some mouseMove,mousDown,mouseUp events for the editor to interact with the widget.

     

    So a custom widget colorlabel would look like this when exported.

    //GUI Editor Generated
    #include "MenuClass.h"
        
    MenuClass::MenuClass(Context* context)
    {
        gui = GUI::Create(context);
        
        //Panel
        Panel = Widget::Create("", 0, 0, 1024, 100, gui->GetBase(), "Scripts/GUI/Panel.lua");
        Panel->SetAlignment(false, false, false, false);
        //Button
        Button = Widget::Create("Template", 81, 38, 150, 20, Panel, "Scripts/GUI/Button.lua");
        Button->SetAlignment(false, false, false, false);
        //Button1
        Button1 = Widget::Create("Template", 338, 38, 150, 20, Panel, "Scripts/GUI/Button.lua");
        Button1->SetAlignment(false, false, false, false);
        //ColorLabel
        ColorLabel = Widget::Create("colorlabel", 710, 39, 80, 20, Panel, "Scripts/GUI/ColorLabel.lua");
        ColorLabel->SetAlignment(false, false, false, false);
        ColorLabel->SetString("align","Center");
        ColorLabel->SetString("valign","Center");
        ColorLabel->SetBool("border",true);
        ColorLabel->SetObject("bordercolor", new Vec3(1,0,0,0));
        ColorLabel->SetObject("textcolor", new Vec3(0,0,1,1));
        //Panel1
        Panel1 = Widget::Create("", 342, 328, 300, 200, gui->GetBase(), "Scripts/GUI/Panel.lua");
        Panel1->SetAlignment(false, false, false, false);
        Panel1->SetObject("backgroundcolor", new Vec3(0.2,0.2,0.2,1));
        //Button2
        Button2 = Widget::Create("exit", 80, 156, 150, 20, Panel1, "Scripts/GUI/Button.lua");
        Button2->SetAlignment(false, false, false, false);
        //Button3
        Button3 = Widget::Create("options", 77, 98, 150, 20, Panel1, "Scripts/GUI/Button.lua");
        Button3->SetAlignment(false, false, false, false);
        //Button4
        Button4 = Widget::Create("load", 76, 33, 150, 20, Panel1, "Scripts/GUI/Button.lua");
        Button4->SetAlignment(false, false, false, false);
    }
    MenuClass::~MenuClass()
    {
        Button4->Release();
        Button3->Release();
        Button2->Release();
        Panel1->Release();
        ColorLabel->Release();
        Button1->Release();
        Button->Release();
        Panel->Release();
        gui->Release();
    }
    //
    bool MenuClass::ProcessEvent(Event event)
    {
        if (event.id == Event::WidgetAction)
        {
            //
        }
        return true;
    }
    //
    bool MenuClass::Update()
    {
        return true;
    }


     

  12. reepblue
    Latest Entry

    Luawerks has been updated this morning, making the console more responsive and a new tab for the Options Menu for user's to bind keys to actions.

    Actions have always been part of Luawerks, but until now, there wasn't really a motive to use them. Now, the Action class look in the config to check what key the user binded to that action. You can read more on how this works here. Like the console, this may be improved more in the future. 

     

    About Luawerks

    Luawerks is a Lua framework for video games developed on the Leadwerks Game Engine. It supplies developers with additional functions, handles the game loop and allows them to debug their code with a developers console. With all that out of the way, you can focus on making your game fun!

    You can purchase Luawerks from the Leadwerks Workshop Store for $9.99.

    For documentation and bug reporting, please visit the GitHub page.

    luawerksgui2.JPG

  13. In a previous developer blog I showed how I use spline paths inside the Leadwerks editor. The cool thing about splines as that they are extremely multipurpose. I started working on generating meshes based on the splines.  Think about ropes, wires, rivers, rollercoasters and of course roads

    Ropes and wires are in progress because I find them the coolest. Especially rope bridges are awesome to make and see in play. They require a lot of finetuning so I have put that on halt for now. In the meantime I also started working on road nodes. The Return to the Zone project uses terrain textures, but the original scene from Leadwerks 2.3 used the in-editor road tool. Time for some new roadfeatures.

    Roads
    The generic nature of the splines allows easy creation of meshes based on the spline. Constructing basic geometry was relatively easy. However, getting the road to appear on the terrain properly proved a little harder. When there is no terrain, the generation of the road is instantaneous. The roads that are created snap perfectly together and it is really satifying to see the result. Per node you can't only tweak the road with the spline handlers, but you can set a road width, a material and several terrain alignment options.

    When the node has to deal with terrain allignment the performance on startup is little slow at the moment, but the first results look promising. I want to add this feature to my winter game "On the road again", which makes cool random tracks from CSG brushes.  

    Another cool automatic feauture is that the road still functions as a path spline. You can attach a car to the road spline and it will follow the generated road. 

     

    Ropes and wires

    For a next video I will show the progress on the ropes and wires, with hopefully some working physics. Here is an older image based on the earlier splines to give you an idea on what I am going for:

    powerlines.png

  14. In my other blog (https://www.leadwerks.com/community/blogs/entry/1908-top-10-celebrities-who-use-component-architecture/) I talked about the component architecture I was using. I've since teamed up with Roland on this idea and together we have fleshed it out more. It's not 100% ready to be released yet but I realized that we've come a long way and that where we are today might seem confusing to someone if they weren't along for the ride. So I thought I'd use this blog to start down the journey we went on.

    The main goal for our journey was as follows:

    - Components will NEVER depend on other components. Decoupling as much as possible was priority #1. So the idea of events and actions(functions) is still at the core of the system. Now components need to work together obviously but the lowest level of dependencies the system has is via the arguments that events send along to actions. If you're hooking an action to an event you need to know what args that    event is sending you. This is primitive data vs classes and it's as decoupled as you can get while still allowing interactions between components.
        
    Coroutines!

    One day Josh asked about coroutines and if anyone knew anything about them. I've used coroutines in the past so I replied and did some examples (still need to finish that for him). Then one day on my way home from work it hit me. Since we have a common communication method in having actions (functions) being called from events we had a centralized place where all component actions (functions) were being called (the event class). This meant incorporating coroutines into our system was simple. Thanks to Roland for fleshing the idea out, all component actions are now coroutines automatically created (no work on the component creator's part). This was very exciting as it meant action functionality that required sequential coding could be done right in the action directly. This helped eliminate the need for most components needing an update() method that might not be doing anything except in certain situations. Situations that are now all handled in an action itself. It also meant a lot less state variables were needed to manage this sequential code. Roland had a doAddHealth() action where he instantly added the value passed in to the players health. This resulted in a snapping of the UI to the new health value. While that clearly works and you can do it that way, the test of our system was to make that health slowly increase to the final value over time, giving it a nice visual animation of increasing health. We were able to do it directly in that doAddHealth() function with about 2-3 more lines of code. It was insanely easy and much more logical in nature. Roland had never used coroutines before and he was able to get it working in a couple mins because it's just very logical and intuitive to work with when you don't have to deal with the details of the coroutine setup and management. You simple work with coroutine.yield() inside your action and that's all you really need to understand. This is an idea I'd like to see Josh think about with normal LE script functions as I think it can make life easier. Tim and I are working on a turn based game. Everything in the game is basically a sequence of actions over time so this idea of all actions are coroutines has been HUGE for our game. More on that at the end of Aug.

    Entity to Entity Communication!

    We fleshed out the entity to entity communication. My last blog talked about component communication with other components inside the same entity (the event system). This works great because all the components are inside the same entity and can access each others events and actions to hook up. But how can a component in entity A do something because a component in entity B wants it to, without those components knowing anything about each other? It was a challenge to get the right idea for this. We wanted to stay with the idea of events for this but we also didn't want entities to know about each other's internals.Decoupling of entities is important or else you end up with dependency hell and tigh coupling. We ended up with giving entities a SendMessage() function and an onReceiveMessage event. So from entity B we can hook up one of it's components events to the entity action SendMessage. The arguments for these required 2 special variables. Dest and Message. Dest is the entity to send the Message to. To get the Dest entity you're component is doing some kind of picking or GetNeighbors(). Dest can be 1 entity or a table of entities. On the receiving entity(s) the onReceiveMessage event is raised so that you can hook it's component actions to a received message. So all communication is done via the event system in some way.

    This introduced 2 needed features to our event system. When you get an event onReceiveMessage is raised no matter what event you got. However you'd only want certain events to trigger certain component actions. This requires some kind of routing of string messages to actions being called. We did this currently with a filter function on the event's subscribe() method. When the event is raised and a filter function exists it'll call the function passing in the arguments of the event and if the function returns true, raise call the action method. If false it wont call the action method. So generally what you do is pass a function that checks the args.Message for the value you want to call the action.

    self.onReceiveMessage:subscribe(self.healthComponent, self.healthComponent.doHurt, function(args)
            if args.Message == "hurt" then
                return true
            end
            
            return false
        end)

    In the above event hookup when the Message is "hurt" then we hook it up to our healthComponent doHurt action. Because this is a very common thing to do, it can be bloated to have to define the function that does exactly this but for different string messages, you can just pass a string instead of a function to make it more streamlined:

    self.onReceiveMessage:subscribe(self.healthComponent, self.healthComponent.doHurt, "hurt")

    As you can see communication is NOT done inside the component. We didn't want components handling communication. We view component functionality and how that functionalty is communicated as 2 different types of coding. Communication is done inside the event hookups and functionality is done inside the component. Because of this and staying with the SendMessage/onReceiveMessage idea, we introduced another idea to the event subscribe() function. Another callback that is called before the action is fired. This also passes in the args and exists to let you modify the args before the action is called. This is used mostly when hooking a component event to SendMessage so that at that point you can give the string Message value. This way the component itself isn't concerning itself with the message which helps keep it more generic. This makes communication implementation specific to YOUR game and not the component. The component is just doing it's ONE job and raising events. That's it. What that means to your game is up to you to code. An example of this is:

    -- nil is the routing/filter function we talked about above which we don't need because we are sending out not receiving in
    self.inputComponent.onPicked:subscribe(self, self.SendMessage, nil, function(args)
            args.Message = "use"
        end)
    

    The inputComponent will raise an onPicked event when an entity is picked by left clicking. It doesn't care what you want to do with that. That's your part of coding your game and is game specific. It will fill in the args.Dest value with the entity but we need a place outside the component to specify what we want our message to be for our game. The supplied function does just that. It let's us create the Message variable on the args and fill it in. On the receiving side then it's up to us to hook up to that entities components when the message is "use" like above in the onReceiveMessage examples. This idea of 2 types of coding I think really helps create more separation and isolation of code which helps with maintainability and reusability. If components were to define the Message value inside then their influence starts to leak out as another component needs to be programmed to deal with that exact Message. We don't want that. We want the messages to be game specific and decided on by the user of the component system not the component creators. There is an alternative syntax to the above code where instead of a function you can specify a table. This table will be merged into the args parameter.

    self.inputComponent.onPicked:subscribe(self, self.SendMessage, nil, { Message = "use" })

    So to summarize entity communication, when sending messages the arguments callback function (or table that gets merged) is useful. When receiving messages the filter/routing callback function (or string message) is useful.

    Cool Side Effects!

    And interesting side effect to to the event system is that they are raised in the order they were subscribed to. You can use that to your advantage if you want to modify the args in any way between multiple components. Tim and I use this concept in our game. When we get a "hurt" message come into a character entity we first pass it through a Stats component which stores information about the player armor and other defenses. The args has a value property on it that is how much damage we should take, but by first running through our Stats component we can reduce that value by our armor. The 2nd component it's hooked up to is the health component which will reduce our health by the value property but now it's less because our Stats component reduced it. Since args is a table and tables are passed by reference the change to an args property in one component is visible to subsequent components.
     

    Summary

    Having a common communication protocol between components and entities has been a big help in structuring my code for maintainability, adding new features, and reusability. One of the benefits of Lua is that table properties can be accessed via their string name. So something you might notice about event hookups to actions given knowing that Lua table properties can be accessed via string names, is that hooking up events is really just configuration. Even though the above examples is code that code can be made very generic where the property names are string values stored in a file. For example the above inputComponent hookup is the same as:

    self["inputComponent"]["onPicked"]:subscribe(self, self["SendMessage"], nil, { Message = "use" })

    Because it's a common structure all event hookups follow the same pattern. So imagine this information is coming from a json file and that json file is built from a visual editor. You would code your components in a code editor but hookup your components in a visual editor as you select the event source, event, action source and action from drop down menus. Thanks to Roland, we will have more to come on that in the next few months...

     

    • 2
      entries
    • 13
      comments
    • 2370
      views

    Recent Entries

    Mattline1
    Latest Entry

    Main post available here

     

    I first presented my PBR work about a year ago, since then I've been tweaking and making improvements.

     

    Over the past 6 months Leadwerks has had some great updates for graphics junkies like me tongue.png .The HDRi and environment probe features look great and have helped with 2 of the main issues with the last PBR system. Now what you see in the editor is what you get in the game, and HDR means proper tonemapping and a wider range of possible light intensities. Both of which are important for realistic PBR.

     

    I currently plan on using this for my current project, so expect consistent updates as I battle test it.

    The current build is available on github. Any issues and suggestions to help improve it are welcome.

    Sponza.jpg

     

     

     

     

     

    Limitations / improvements

    • Requires a gamma-correction post process shader. Not a huge issue, adding a pp is pretty easy but still something to remember.
    • Currently the built in environment probes are stored in a low dynamic range. This leads to clamping and precision errors as HDR values move towards extremes. this limits the usefulness of HDR. This is an engine issue.
    • Probes also use simple mipmapping for different roughness values, PBR often performs a convolution on stored cube-maps to better match reflection blurring due to roughness. A fix may be possible for this, but would require C++.

     

    Racer.jpg

    </p>

  15. Hi! It has been a while. Here's an update on my networking library EvayrNet which is available for C++ users of Leadwerks:

     

    While implementing it into the test project in Leadwerks, I saw that the use case had some flaws which made it really hard to debug what's going on. I figured that I should be spending some time on fixing some flaws. After a few weeks I came up with the following upgrades:

    1. Debugging class
    2. Simulation mode
    3. More debugging information available

    Here's some detailed explanation:

     

    Debugging class

    I was using a lot of "printf" before which made it hard to:

    • Find out where it's being called
    • Disable whenever I don't need it anymore

    This is when I decided to make a debugging class. I replaced the printf with a custom Print function which allows you to do the same as before - except you can disable any kind of printing whenever you want (like during release builds).

     

    I also realized that capturing data is a pretty cool feature to have, which makes it easier to visualize the data you want to debug. For that I created a SaveText function which accepts a string and a filename as arguments so you can separate data like "Pings per interval", "Bytes sent per second", etc.

     

    Here is an example what you can do with it:

    blogentry-358-0-42708300-1490806770_thumb.png

     

    Simulation mode

    This is an interesting one that I just had to implement. A connection cannot always perfect, and it can be hard to always expect a good outcome (while you might not notice it because of your tests on localhost). This is why I introduced the manipulation of the following networking stats:

    1. Minimum latency (in ms)
    2. Random latency (in ms)
    3. Packet drop percentage
    4. Packet duplication percentage

    It's also very easy to activate and deactivate. All you have to do is NetworkManager::StartSimulation(...) and StopSimulation(). Here is it in the command line when you activate it:

    blogentry-358-0-27976100-1490807270_thumb.png

     

    More debugging information available

    At last I added more ways to debug the network statistics to really see what is going on. Are you not receiving data anymore? Are you flooding the network? The following information is now ready to be displayed:

    • Newest ping (either to the server or from a specific client)
    • Average ping (this as well^)
    • Incoming amount of packets per second
    • Outgoing amount of packets per second
    • Packets per second lost
    • Incoming data per second (in bytes)
    • Outgoing data per second (in bytes)
    • Current active connections (primarily for the server)

    That's... quite a lot more than before! Previously you could only see if you're connected and if you're the server. I hope this information will make it easier for users to visualize traffic and debug any problems they might be having. And of course, you can mix this up with the debugging class to make cool graphs like above!

     

    Final words

    I'm still planning on making some extra information, like on specifics to see what kind of message is creating the amount of bytes send/received. This should help debugging even more. Other than that there are still some enhancements I'd like to put in such as encryption. These can be seen here.

     

    I hope you liked this blog post! Next time I will probably be showing how to implement EvayrNet into your C++ Leadwerks project, so you can toy around with it. wink.png

  16. I have made a small class for helping with reading and writing parameters between C++ and LUA and also calling LUA functions from C++. I'm sharing this little thing here.

     

    blogentry-395-0-01293300-1488719654_thumb.png

     

    Using the class is quite simple as shown below

     

    LUA - part

    blogentry-395-0-18534700-1488720057.png

     

    C++ - part

    blogentry-395-0-59572000-1488719924_thumb.png

     

    I have included is a test project which looks like this in the editor

    blogentry-395-0-25132300-1488720141_thumb.png

     

    And like this when executed

    blogentry-395-0-63899000-1488720151_thumb.png

     

    Here is the LuaBridge class source

    Luabrigde.h

    Luabrigde.cpp

     

    And the complete test project

    LuaBridge.zip

     

    Note: Its says 'Click for next test', should be 'Hit Spacebar for next test'

  17. It should be great if you can create a game world which has exact real-life object's dimensions. If you are using Blender to make game props for Leadwerks, these are some simple steps to help you archive the dimension match up.

     

    Step 1:

    - In Blender, go to Properties panel > Scene tab > Unit group

    - Choose "Meters" from list.

    - Make sure Length = Metric, Angle = Degree, Unit scale = 1

     

    Step 2:

    - This step is optional but can make you feel better with grid floor

    - In 3D View, Press N to open Properties region > Display group

    - Change Lines = 256, Scale = 0.1

     

    objectdimension1.jpg

     

    From now on, you can adjust object's dimensions parameters in Properties region to match real-life dimensions, it will be the dimensions when you import models into Leadwerks.

     

    Don't for get to Apply Transformation for object model, it is important. Do this before adjust object's dimensions. In blender Use Ctrl + A > Location / Rotation & Scale.

     

    objectdimension3.jpg

     

    Step 3: Fbx export

    - Menu File > Export > Fbx

    - Choose Version = FBX 7.4 binary

    - Scale = 0.01

     

    objectdimension2.jpg

     

    Step 4: Adjust exported model in Leadwerks Game Editor

    - Double click mdl file in Assets Explorer to open it in model editor.

    - Menu Tools > Collapse. This make sure model local rotation is correct.

    - Menu Files > Save.

     

    I attached my template .blend file below this post. It included a 1.7m height human model for better reference.

    • 2
      entries
    • 7
      comments
    • 659
      views

    Recent Entries

    aiaf
    Latest Entry

    Ive decided to plan better and fix milestones so i can actually finish this game, the main problem is lack of time.But i have patience.

     

    I got a domain and in the process to setup a website and a blog.The plan is to have a small release every 15 days.

    Will see how it goes, it would be nice to work full time on this but not possible at this time, still have to go to work for a living.

     

    Currently im about to finish a somewhat starcraft like resource gathering mechanic.

    A mine has a 1 transporter that gather resources from asteroids.

    I limited to just 1 resource transporter per mine so that the user has incentive to expand (build mines) for more resources.

     

    Will come back with a movie.

     

    For development stuff i want to say Object::GetAddress method is great.

    Besides the debugger, really helped to investigate some strange crashes.

     

    http://www.leadwerks.com/werkspace/page/api-reference/_/object/objectgetaddress-r26

     

     

    Cya

  18. blog-0568459001486305707.jpg

    One More Day - Performance Updates

     

    So it’s been a while since my last blog update on One More Day but recently I had a look to see if I could do anything with improving the performance of the game. As it turns out there were still some optimisations to be made that have helped boost performance.

     

    V0.1.6 on the Game Launcher

     

    Here are the main performance related changes I’ve made which were recently published to the Game Launcher:

    1. I changed some of the furniture models to lower poly versions. Some of these models were about 3000polys and are now replaced with lower poly versions with no real visual difference in-game. So about 10 or so models that were repeated more than once around the level were shaved in poly detail by about a third.
    2. I halved the draw distance on camera range and increased the fog a bit to compensate. I believe this helped more for when you are some distance outside the town but less so when you are in the town.
    3. I removed some rogue geometry in the map (wasn’t much), and also a few objects that weren’t really needed.
    4. I went back over every object to ensure it’s viewing range was as minimal as I could afford without creating too much pop-up. This is something I have always done but still sometimes you end up missing a few things.
    5. I spaced out some detailed areas on the map (ie. the power station got moved out further) to try to reduce the number of objects being shown at any one time.
    6. I made sure physics shapes set in model viewer were as simple as possible and removed collision from some small objects.
    7. I removed some workshop objects that had very big textures.

     

    All these changes stacked on to the latest version of Leadwerks which also includes performance improvements have given a noticeable performance improvement to the game.

     

    One thing I had to add in (sparingly) was some grass using the vegetation system as I felt it added nice detail to the level and was worth a small performance hit. That’s what makes optimising the game hard, trying to balance between good visuals, content and good performance. Unfortunately sometimes sacrifices have to be made. But even with the grass added the new version is running better than before. I would like to add volumetric spot lights for light coming in the windows but for now I resist that temptation as they would add up to a significant performance hit. Maybe I will add them as a high graphics option in the future.

     

    Other Improvements

     

    As well as performance improvements the game download size is now smaller thanks to the newly added ogg support and also removal of some unused files that were being published. One thing I noticed when publishing a game in Leadwerks is that if you have files with the same filename in two different folders both files will be packaged even if only one of them is used. So there were some unneeded texture files etc. being packaged from unused workshop content. Going forward I will have to keep an eye out for duplicate filenames.

     

    More performance in the works

     

    The following changes are in my current dev build which hasn’t been released yet but are showing even more performance increases:

     

    1. Converted the CSG houses and bungalows to models. Simplifying and reducing object/entity count. This should allow me to add more houses to the map with less of a performance impact.
    2. Further reduced the camera range and increased the fog to compensate. This allows me to reduce the view range on many bigger outdoor objects and buildings from Max to Far whilst minimizing popup and also reduce the vegetation view range. This will result in a much more foggy look to the game (see screenshot) which will create a slightly different atmosphere than previous versions and with less viewing distance it might make approaching zombies a bit more dangerous.
    3. I identified SSAO was making quite a performance impact so I have disabled this for now and might re-introduce it as a high graphics option when I get around to creating an options menu. For outdoor map SSAO is probably not as important or worth the hit but it is nice to have when inside the buildings.

     

    After all these performance improvements and v1.7 is released I am optimistic that most people should get at least a 30fps game experience with OMD. Fingers crossed!

  19. After going radio silent for a week I return with some really, really good news.

     

    First and foremost, the last level of the first episode is finished, I'm currently testing it out and seeing if I can break it before I upload a beta build to steam. After a couple days of it being there, if there aren't any issues, I will be launching the game on february 10th. Yes, you can quote me on that.

     

    3c5bdc3d87f763539e11a5dc8898de8920700fc3.jpg

    I have to tell you though, making this level was not easy at all, I had so many ideas that never saw the light of day, but I hope that the way I created things work out for the better and I hope to use those scrapped ideas in the future someway.

     

    So here's a bit of information for the last level for those of you who've been wanting to play it:

     

    There's a way to kill the demon.

    There's a way to escape without killing him.

    The last level has 5 different variations depending on what you do.

     

     

    It goes without saying that there are multiple endings for what happens when you finish the last level as well, but I'll leave that for you to find out.

     

    55ea894a743061a3d64b1a22cecaadcd093947cd.jpg

     

     

    That's it for now! I've probably already said too much so I hope you'll like what's in store for you.

  20. It's finally done!

     

    You can find it here on the workshop:

    http://steamcommunity.com/sharedfiles/filedetails/?id=843127624

     

    And now i'm going to share a bit about the progress of the last few weeks, stick around if you like :)

     

    I'm so glad i made it in time, there were still a few "optional" things i would've loved to add (like a final boss wave) but due some in real complications (losing my phone..) and overal internship time consumption i still managed to get quite a game here!

     

    I am pretty proud of it too, might sound silly for such small game but it's my second game that i marked as "complete"! Also special thanks to my wife for creating all the model textures & GUI textures!

     

    For both me and my wife it was the first time we actual worked with 3D models (creating them from scratch and texturing them from scratch) this was quite a cool experience, i'm really glad with the results

    and i got more experienced in the tools i can use to make things look nice without too much complications.

     

    I personally think the cartoon-ish style was a great start for the modeling / texturing matter as this are my first proper game models that i build from scratch like mentioned above. I did have a small glimpse and trying to add bones, but i personally left it aside for now as i didn't really need them and i wanted to invest my time more in the game to reach the finish line.

     

    Overal in general, the progression went smooth (sometimes a stupid mistake like uppercase instead of lowercase.. You know the deal hehe), this was also my first time actual creating a wave system which i enjoyed a lot! I must say, tweaking & balancing each wave was harder then i honestly expected at first but i think i found quite a balance :)

     

    I don't really know what more to add haha, perhaps writting this after a day programming session wasn't the best idea.

     

    Thanks for reading and i hope you guys enjoy the game as much as i did creating it!

    • 2
      entries
    • 8
      comments
    • 367
      views

    Recent Entries

    In my day job I get a lot of experience with different technologies. Mostly related to mobile or website, but there is a lot of bleed over in the game industry. I've done a few Ruby on Rails applications, it's not my primary toolbox, but it has some benefits. Mostly the ease and speed of development.

     

    I switched to using Ruby on Rails for the data management layer of my game. At the moment there isn't much data, only about 300 rows in a database for everything in the game. This is expected to more than triple within the next few months as I add achievements, more items, 7 new quests, and shops!

     

    Eventually this will go extremely large and hard coding all that data will become very error prone and next to impossible to manage.

     

    Ruby on Rails has the ability to have command line tasks which can be used to generate data.

     

    Sample task:

    namespace :codegen do
    task :achievement_types => :environment do
     erb = ERB.new(File.read('lib/tasks/codegen/achievement_types.erb'))
    
     params = binding
     params.local_variable_set(:achievementTypes, AchievementType.all)
    
     data = erb.result(params)
    
     f = File.new('codegen/AchievementType.h', 'w')
     f.write(data)
     f.close()
    end
    end
    

     

    What this code does is it loads an ERB file which is a templating file for Ruby.

    Queries the database for all AchievementType objects,

    Then creates a local binding scope for the template,

    Renders the template to a string

    Presto, Generated C++.

     

    Erb file in question:

    #ifndef ACHIEVEMENT_TYPE_H
    #define ACHIEVEMENT_TYPE_H
    <% achievementTypes.each do |at| %>
    #define <%= at.macroname %> <%= at.id %>
    <% end %>
    #endif
    

     

    Code generated:

    #ifndef ACHIEVEMENT_TYPE_H
    #define ACHIEVEMENT_TYPE_H
    
    #define ACHIEVEMENT_TYPE_WOODCUTTING 1
    #define ACHIEVEMENT_TYPE_FISHING 2
    #define ACHIEVEMENT_TYPE_MINING 3
    #define ACHIEVEMENT_TYPE_FIREMAKING 4
    
    #endif
    

     

    The use case above is fairly simple, but more complex situations can occur, such as Npc Conversations. Currently my NpcConversation_Gen.h file is 500 lines long. with lists of data similar to this:

     

    new NpcConversation(34, 0, "69488b5b-cfd1-4255-bd74-a6b7eeb0e939",
    {
     new NpcConversationAction(27, "AddInventoryItem", 39, 1),
     new NpcConversationAction(28, "CompleteMilestone", 3, 15),
    },
    {
     new NpcConversationConditional(12, "StartedQuest", 3, 0),
     new NpcConversationConditional(13, "HasItem", 57, 10),
    }
    ),
    

     

    Maintaining that code by hand would triple the amount of time to create quests.

     

    So if your game uses a large amount of data, I really recommend using a web framework (Ruby on Rails, Codeigniter, Cakephp, Revel, Django, Spring, ect) to manage all your game data!

  21. blog-0813764001483675955.png

    I've finished the main concept of my game "Ball Hopper", which you can play at http://www.leadwerks.com/werkspace/page/viewitem?fileid=831630240

     

    It was inspired by CS:GO surfing and the Impossible Game and your goal is to reach the checkpoints and get to the end. Checkpoints, for a lack of a better word aren't what you'd expect of them. They're really just points that you need to touch to be able to finish the level. Some level end points are right at the start, so would be a bit silly if you could just get to the finish and win, so that's what those are for. You don't actually respawn at those points.

     

    This blog post is mainly to gather feedback before the end of the tournament, so let me know if you have any suggestions.

  22. Hey!

     

    More stuff will come in the next version, my objective is to improve the Prologue to use as a demo for a Greenlight campaign to the next chapter. Much of the work this week (besides fixing stuff) was to detail the scenes a bit more to help you guys understand the water flood and how deep the water is.

     

    I removed the cars of the starting area, because floating cars in that place makes no sense.

     

    20161216133209_1-pzdpq8v2.jpg

    You can now even see the noisy bird (what a time to be alive!)

     

    The water in the game is really deep, the buildings you see in the game are the rooftops and the facility that you start the game barely survived to the cataclysm.

     

    Some additional rooms were planned for prologue but they were left out, I'll add them in the new version! So if you have already played the prologue you will have some surprises in the Uncut version.

     

    20161216133113_1-5vujssxw.jpg