Benjamin De Cnuydt

Wushu Legacy is a game developed by five motivated students at Game Academy. During five months, we had to develop a fully packaged project by following a strict planning and game design document. The main challenge was to learn how to work as a team, respect timing and produce valuable prototypes. My role as a producer consisted in maintaining a good development pace, sharping my curiosity in other aspect of game development provided by my colleagues and be fully aware of every aspects of their works in order to manage ressources and reach goals.

What I did so far

Programmation of the path to follow and camera automation
Configuration of the difficulty and enemy waves
Programmation of the dodge & throw mechanic
Programmation of the enemy behavior & attack timing computation
Programmation of animation blueprints, blendspaces & montages
Manage sprints, planning, playtests & social network with #SCREENSHOTSATURDAY
Add scenarios and life in the environment with level streaming

Main challenges

Maintain consistency both in artistic and programmation tasks
Make animations smooths for the gamefeel and gameplay's logic
Keep a good pace through the sprints
Find a difficulty balance for players of all kind
Avoid softlocks
Adapt a logic to fit with two game modes (solo & versus)

Gameplay

Encode & hit

Observe enemy intent and encode the inputs on time when they appear to neutralize the enemy and earn points. If you're motivated enough you can skip those inputs and memorize hidden combos to earn more bonus points!

Dodge your problems

You missed an input? It's time to dodge that blade and keep going. When you defeat an enemy, you fill your bonus bar and gain special abilities once it's full. You can keep only two bonuses at the same time, use them wisely. Keep in mind that dodging doesn't give you points !

Path followed by camera & characters

Challenge

Construct the spline automatically from the start to the end of the track
Find compromises between environment artist & programmer to adapt easily on every level
Adapt collisions between characters and the track
Make it appropriate for the versus mode

What we did

Create a custom rail rig in order to add splines alongside for the versus mode
Create a level sequence and a cinema camera independent of the character's blueprint
Predeploy the rail and construct splines at runtime
Investigate landscape spline mesh components as a redundant pattern

How to improve ?

The beginning and end of the spline are sometimes messy by adding extra points and curves that need to be manually deleted
Improve plane surface on the landscape spline to avoid feet to clip inside it
Access an attribute more accurate than spline mesh components (controls points preferred) to improve tangents accuracy of the splines
Find a way to detect meshes at startup avoiding to precompute the path

Landscape spline mesh components

Custom rail rig construction script

Initiate splines when the game starts

Add point to a specific spline according to the floor

Camera tracking & anticipation

Challenge

Allow the player to anticipate incoming enemies on the road bends
Not disadvantaging a player during versus mode due to shift when characters are turning

What we did

Add an actor following the rail rig and in front of players (anticipation distance)
Make the cinema actor track this actor in order to focus on the next enemies without abrupt shifts
Adapt the focal length of the camera to suit with the versus mode
Compute character speed ratio according to landscape spline length and automatically adapt the rail speed

Actor to track in red

Camera speed

The logic behind the attack mecanic is governed by the notify system in animations. Thanks to that system, we could easily adjust the timing where the hero attacks, triggers the soldier's death and update the queue of enemies facing Akakin. By using a spline path, we could also compute the time separating the player with the next enemy, allowing us to implement a map containing custom delays for each specific animation depending on the method used by the player (basic inputs or combos).

Challenge

Avoid soft lock in case of early aborted animation impacting the integrity of the enemy's queue
Adapt speed and timing of animations in order to fit any king of enemy wave configurations

What we did

In order to keep the integrity of the enemy's queue, we implemented securities through three scenarios. Each scenario activates the same logic by resetting values for the next enemy and remove the defeated enemy as soon as possible in case of short space between them.

When Akakin strikes successfully, this is governed by his notifies
When the enemy strikes and hurt Akakin, governed by enemy notifies
Akakin dodge the enemy, this one can't count on notify because we could not be sure if an enemy is avoided this way. To compensate this system, we had a collision box behind each enemy to trigger the logic

How to improve ?

A way to improve this system would be to rely only on the time calculated to reach an enemy and activate the logic with a delay suitable for all animations by setting a duration threshold for them.

Time remaining before impact

Notify system

Security collision box

How does score work ?

For each enemy, points are computed by taking count the following parameters:

Remaining time between Akakin and the next enemy (greater is better)
Basic inputs or combo ? (combos are 1.25x better)
Number of inputs needed to kill the enemy

Firstly, we take the remaining time and compare it with an array containing fixed values in order to attribute a score going from 0 (OK) to 3 (Perfect). This score corresponds to the multiplicator used to compute the points by multiplying the base point (10) by this score. We don't forget to also multiply by the killing spree multiplicator (clamp to 9 maximum) corresponding to the number of enemies the player killed without getting hurt. Finally, we multiply by 1.25 if the player executed a combo.

To compute the score, we take in count the number of inputs needed to kill the enemy. Indeed, pressing one input is faster than four inputs and we adapt to let the "Perfect" still possible.

How does wave work ?

Waves of enemies are configured thanks to a Python script where we can precise multiple parameters in order to set up a specific difficulty. These parameters are:

Speed of Akakin
Distance between enemies
Number of inputs needed for each enemy
String of inputs and enemy types

According to some parameters, the script will generate a String containing the type of enemy represented as number and inputs represented as a capital letter. Each letter corresponds to a map key and allow the game to set up the correct buttons texture for the player to press. Depending of the player's choice, those textures vary also with the type of controller used.

Once all waves are created, we insert them inside a data table. This data table will be used during the spawn of enemies and at the end of a wave in order to update the distance between enemies and the speed of Akakin.

Score computation

Wave datatable

Setup of the difficulty at end of wave

Wave generator


import random

inputs = ["U","D","R","L","A","B","Y","X"]
nb_type = 4

#Avoid inputs starting with same button than combos
combos = {0:"X",1:"A",2:"D",3:"B"}

nb_proba = 1000000

def create_wave(wave_number, input_length, nb_enemy, max_same_input, nb_type_enemy, is_running, proba_run):
    enemy_types = []
    inputs_list = []
    run = []
    clone = []
    f = open("wave"+str(wave_number)+".txt","w")
    for i in range(0,nb_enemy):

        inp = ""
        rand_type = random.randint(0,nb_proba)%nb_type_enemy
        while len(inp) < input_length:
            rand_inp = random.randint(0,nb_proba)
            button = inputs[rand_inp%8]

            if inp.count(button) < max_same_input and button != combos[rand_type]:
                if (len(inp) >= 1 and inp[len(inp)-1] != button) or len(inp) == 0:
                        inp+=button
        inputs_list.append(inp)
        enemy_types.append(str(rand_type))
        if is_running == 0:
            run.append(str(is_running))
        else:
            rand_run = random.randint(0,nb_proba)
            clone.append(str(0))
            if rand_run <= nb_proba*proba_run and rand_type!=3:
                run.append(str(1))
            else:
                run.append(str(0))
    enemy_types.append(str(9))

    for enemy in enemy_types:
        f.write(enemy)
    f.write("\n")
    for inpu in inputs_list:
        f.write(inpu)
    f.write("\n")
    for r in run:
        f.write(r)
    f.write("\n")
    for c in clone:
        f.write(c)
    f.close()

create_wave(43,4,5,1,4,0,0)

Clash Island is a game developed during my first Game Jam. Even if I'm used to this kind of event thanks to Hackathons, it was a surprise to discover a new feeling in this video game atmosphere. Instead of being surrounded by programmers, I loved share with artists and designers about aspects I didn't know and make correspond our desires through a video game development.

Gameplay

Pick and collect

Props are decimated around the crashed plane. Suitcases, crates, grab whatever you want to notify your rescuer with a big SOS on the sand.

Write to score

Not enough places in the plane ? Oust your opponents with a more noticable SOS in the allotted time. Align props on the shape and earn some points. Get some bonus points by completing correctly a letter and crush the competition.

Get out of my beach

Someone is stealing props on your letters ? Get them out by smashing a plank on their face, they will drop the prop and get ejected.

Don't forget some vitamins

Not enough props on the beach ? Stand with your friend around a banana tree and shake some bananas out of it, this is the perfect alternative ... also a delicious one !

Credit

Music by EMORY Mica: In Virginia

Beginning in mobile development and willing to make Bouftools great again by finding a new concept. Dofus Retro doesn't have in game XP and drop simulation, I wanted to develop a tool where players could access this feature easily.

Steps

Seeking data & formula

First step was to access monster base XP and the formula, hours of putting internet upside down to find tracks and assumption to finally reach a correct simulation. Many in game tests were also necessary to make sure of the correctness.

What I did: Match multiple sources of old Dofus data and elaborate scripts to gather them regularly.

Probability

With the help of Florent Huylenbroeck, we elaborate the computation of drop probability for one monster at a time.

Single: Compute the probability of one player considering his prospection, item quantity available and his place in the team.
Team: Compute the probability of the whole team and display the highest percentage to get a certain quantity.


    calculateDrop(root,qmax) {
    
        // Calculate for the active player
        var proba :any
        if (this.character != ""){
            let pp = this.team.find(i => i.uuid === this.character).prospection
            let index_actif = this.team.findIndex(x => x.uuid ===this.character);
            proba = parseFloat((this.charSearch(root,index_actif)*100).toPrecision(4))
            if (proba > 100){
            return 100
            }
            return proba
        }else {
            //Calculate the average drop for the whole team according to quantity
            proba = parseFloat((this.teamSearch(root,qmax)*100).toPrecision(4))
            if (proba > 100){
            return 100
            }
            return proba
        }
    }
    
    
    charSearch(root,j){
        return this.charSearchRec(root, j, 0)
    }
    
    charSearchRec(node:Node, j, currentDepth){
        if (currentDepth < j){
          let tmpleft = 0
          if (node.left != null){
            tmpleft = this.charSearchRec(node.left, j, currentDepth+1)
          }
          let tmpright = 0
          if (node.right != null){
            tmpright = this.charSearchRec(node.right, j, currentDepth+1)
          }
          return tmpleft+tmpright
        }else if (currentDepth == j){
          if (node.left != null){
            return node.left.p
          }else {
            return 0
          }
        }
      }
    
      teamSearch(root,qmax){
        return this.teamSearchRec(root,qmax)
      }
    
      teamSearchRec(node:Node, qmax){
        let total = 0
        if (node.q == qmax && node.left == null && node.right == null){
          total += node.p
        }else{
          if(node.left != null){
            total += this.teamSearchRec(node.left,qmax)
          }
          if(node.right != null){
            total += this.teamSearchRec(node.right,qmax)
          }
          
        }
        return total
      }
    
    }
    
    
    tree(node:Node, currentDepth, qmax, probs){
        if  (currentDepth < this.team.length){
          if (node.q < qmax){
            node.left = this.tree(new Node(node, node.p*probs[currentDepth], node.q+1), currentDepth+1, qmax, probs)
            node.right = this.tree(new Node(node, node.p*(1-probs[currentDepth]), node.q), currentDepth+1, qmax, probs) 
          } else {
            node.right = this.tree(new Node(node, node.p, node.q), currentDepth+1, qmax, probs)
          }
          
        }
        return node
    }
    
    class Node{
      parent:any
      p:any
      q:any
      left:any
      right:any
    
      constructor(parent : any, p:any,q:any) {
        this.parent = null
        if (parent != null){
          this.parent = parent
        }
    
        this.left = null
        this.right = null
    
        this.p = p
        this.q = q
    
      }
    }

Steps

Framework & algorithms

First step was to find a suitable framework and algorithms to detect cards one by one and accurately.

Difficulties: Create a dataset and correct training routine, compare and experience different models.
Solutions: Consider cards artworks for training, chose Darknet & Yolo because of the efficiency and plenty of documentation available.

Embedded system

Once the base model was accurate enough, I tried to adapt it on microcomputer like Raspberry Pi in order to easily add it to the future machine design.

Difficulties: Find a correct balance between speed and accuracy. Convert the Yolo approach into a library designed for embedded systems.
Solutions: Export the detection on a private server for privacy and efficiency.

Design the machine

Finally, the design of the machine is the last step that I'm currently experiencing in order to merge every part of the project.

Difficulties: Elaborate 3D models and check possible patents. Find a balance between speed and card respect.
Solutions: Open source 3D robot arm and suction cup to manipulate the cards.

Achievements

Analyze game logic and packets
Train OCR model
Website development and big data management
Discovering other community website and motivated developers
First step in versioning and project management

Beginning in web development, I wanted a unique challenge in order to mix different disciplines. Data scraping, packet analysis, OCR and botting were really interesting to elaborate reverse engineering and snoop behind the scene of a video game.

Steps

OCR & Macro

First iteration was to configure macros to connect my character in the game and browse merchants NPC. Gathering prices by training an OCR based on Dofus font and an errata list to correct possible wrong interpretations.

Cons: Unreliable macro, only one server available, time consuming and Dofus changed font style
Next step: Find an existing API allowing to gather prices

Bot socket

Next iteration was a technological watch to gather in game data. A jump into the dark side made me seek developers behind a bot socket. After a little talk about Bouftools, we agreed for a free use of their program and no advertising from me.

Pros: Reliable, quick and multiple servers at once
Cons: Need to subscribe accounts

Last updates

After some reverse engineering and game updates, I found some solutions.

Ankama reduced number of merchants (less move from the bot)
High level items still available if asked to the non subscriber zone merchant
No need to subscribe accounts anymore

We had to develop two AI, one random (Random captain Iglo) and one more developed (Eat my fish stick). Those two AI must work with both turn by turn and simultaneous play mechanics. I'm going to explain only the non random.

Complete report

Steps

Message passing & rules

Submarines have access to all actions from each other through messages passing on a stream . At the beginning of the game they don't know ennemies position and can fire mines, missiles and sonar to locate (more or less accurately) enemies. The game ends when only one submarine remains.

AI code

AI logic

Trust list: Each submarine got a list with enemies coordinates and a list with a trust factor (0, 1 and 2 from trusty to untrusty) depending of the sonar quality and the progress of the game.
Analyze intents: Depending of ennemie's actions, each submarine keeps track of health, landing mines and moves. For instance, if one submarine is hurt by a mine, everybody is aware of this event. Depending of damages taken, all submarines update their trust list and define a prey.

I'm Benjamin De Cnuydt

Projects

Game Academy

GGJ21 game

Community app

A Captain Sonar video game

TCG sorting machine

Community website

About Me

Contact Me

Contact Info:

Gameplay

Path followed by camera & characters

Landscape spline mesh components

Custom rail rig construction script

Custom rail rig construction script

Initiate splines when the game starts

Add point to a specific spline according to the floor

Add point to a specific spline according to the floor

Camera tracking & anticipation

Actor to track in red

Camera speed

Time remaining before impact

Notify system

Security collision box

Score computation

Wave datatable

Setup of the difficulty at end of wave

Achievements

What I did

Gameplay

Achievements

Steps

Achievements

Steps

Achievements

Steps

Achievements

Steps