Blogs

Our community blogs

  1. Welcome back to day 31!

    Yesterday, we created a simple time-based system that runs on our screen when the game plays. We only increased the time, but we never pause it when the game is over.

    Today, we’re going to:

    1. Pause our time after we win or lose
    2. Stop our player’s shooting animation and sound effects when the game is over

    Today’s going to be a relatively short day, but let’s get to it, shall we?

    Step 1: Stopping the Timer at Game Over

    To stop our game from showing updates to the timer, we need to have 2 things:

    1. Code to stop our ScoreManager from updating the string
    2. Some way for our ScoreManager to know that the game is over. Who’s in charge of that? Our GameManager!

    Step 1.1: Stopping ScoreManager from Updating Code

    The first thing we need to do is to get our ScoreManager to stop updating the time when the game is over.

    Here are the changes we did:

    using UnityEngine;
    using UnityEngine.UI;
    
    public class ScoreManager : MonoBehaviour
    {
        public Text Score;
    
        private string _time;
        private bool _gameOver;
    
        void Start ()
        {
            _time = "";
            _gameOver = false;
        }
    
        void Update()
        {
            if (!_gameOver)
            {
                UpdateTime();
            }
        }
    
        private void UpdateTime()
        {
            int minutes = Mathf.FloorToInt(Time.time / 60);
            int seconds = Mathf.FloorToInt(Time.time % 60);
            float miliseconds = Time.time * 100;
            miliseconds = miliseconds % 100;
            _time = string.Format("{0:0}:{1:00}:{2:00}", minutes, seconds, miliseconds);
            Score.text = _time;
        }
    
        public void GameOver()
        {
            _gameOver = true;
        }
    }

     New Variable Used

    The goal is for us to stop the call to UpdateTime() to do that, we introduced a new bool called _gameOver to indicate that.

    Walking Through the Code

    The change that we’re making here is straightforward:

    1. In Start() we set instantiate _gameOver
    2. In Update() we update our time if we’re still playing otherwise we don’t do anything
    3. We created a public GameOver() so that something else (our GameManager) can tell us that the game is over and we can stop updating our score

    Step 1.2: Updating our GameManager to call GameOver() in ScoreManager

    Now that we have a way to stop our timer from going, the next thing we’re going to have to do is call it.

    Luckily for us, we have a GameManager script that takes care of everything regarding the state of the game. Let’s add our code there!

    Here are our changes:

    using UnityEngine;
    
    public class GameManager : MonoBehaviour
    {
        public Animator GameOverAnimator;
        public Animator VictoryAnimator;
    
        private GameObject _player;
        private SpawnManager _spawnManager;
        private ScoreManager _scoreManager;
    
        void Start()
        {
            _player = GameObject.FindGameObjectWithTag("Player");
            _spawnManager = GetComponentInChildren<SpawnManager>();
            _scoreManager = GetComponent<ScoreManager>();
        }
    
        public void GameOver()
        {
            GameOverAnimator.SetBool("IsGameOver", true);
            DisableGame();
            _spawnManager.DisableAllEnemies();
        }
    
        public void Victory()
        {
            VictoryAnimator.SetBool("IsGameOver", true);
            DisableGame();
        }
    
        private void DisableGame()
        {
            _player.GetComponent<PlayerController>().enabled = false;
            _player.GetComponentInChildren<MouseCameraContoller>().enabled = false;
            _player.GetComponentInChildren<PlayerShootingController>().enabled = false;
            Cursor.lockState = CursorLockMode.None;
            _scoreManager.GameOver();
        }
    }

    New Variable Used

    Like what we said earlier, we introduced our ScoreManager object, _scoreManager so we can call GameOver().

    Walking Through the Code

    There aren’t any major or surprising changes that were done:

    1. In Start() we got our _scoreManager that was attached to our GameManager game object
    2. In DisableGame(), where we go and disable everything, we call GameOver() from our _scoreManager to pause the timer.

    Step 2: Fixing the Player State After the Game Ends

    The next thing we’re going to do is fix a problem that I’ve been talking about for the past 2 days or so. When we win, our player, specifically, the gun, is stuck in a perpetual shooting state and the shooting sound effect will keep playing until the game is over.

    We’re going to fix that.

    Most of the code is already in place, we just need to:

    1. Create a new state transition to stop shooting in our gun Animator
    2. Create a new game over function for our gun to stop everything when the game is over
    3. Call the game over function from our GameManager

    Step 2.1: Create Transition to Stop Shooting

    If you might recall from Day 16 where we added our weapon, we created a state machine that would transition from our shooting animation to our idle information (and vice-versa) whenever we activate our Shoot Trigger

    gun-animator-controller.png

    We’re going to make a new GameOver state and create a new transition from Any State to GameOver.

    Here’s what we’re going to do:

    1. Select Player > Main Camera > MachineGun_00 and open the Animator tab (Windows > Animator)
    2. Create a new parameter, it’ll be a trigger and call it GameOver
    3. Create a new state called GameOver
    4. Create a new transition from Any State to
    5. Select that transition and set the transition condition to be when GameOver is triggered

    When you’re done, we should have something like this:

    new-transition-state-1-1024x435.png

    At this point, you might be wondering, if we don’t have any clip for our GameOver state, why not just re-use our default state?

    The answer to that is, because this is our finished state where we’re done. We don’t want to accidentally trigger a new transition and move us from the default state to another state.

    Step 2.2: Add GameOver in PlayerShootingController

    Now that we have our new transition, it’s time to use it!

    As we might recall, the script that controls our player’s shooting is PlayerShootingController.

    We’re going to go in and make some slight changes:

    using UnityEngine;
    using System.Collections;
    
    public class PlayerShootingController : MonoBehaviour
    {
        public float Range = 100;
        public float ShootingDelay = 0.1f;
        public AudioClip ShotSfxClips;
        public Transform GunEndPoint;
        public float MaxAmmo = 10f;
    
        private Camera _camera;
        private ParticleSystem _particle;
        private LayerMask _shootableMask;
        private float _timer;
        private AudioSource _audioSource;
        private Animator _animator;
        private bool _isShooting;
        private bool _isReloading;
        private LineRenderer _lineRenderer;
        private float _currentAmmo;
        private ScreenManager _screenManager;
    
    
        void Start () {
            _camera = Camera.main;
            _particle = GetComponentInChildren<ParticleSystem>();
            Cursor.lockState = CursorLockMode.Locked;
            _shootableMask = LayerMask.GetMask("Shootable");
            _timer = 0;
            SetupSound();
            _animator = GetComponent<Animator>();
            _isShooting = false;
            _isReloading = false;
            _lineRenderer = GetComponent<LineRenderer>();
            _currentAmmo = MaxAmmo;
            _screenManager = GameObject.FindWithTag("ScreenManager").GetComponent<ScreenManager>();
        }
        
        void Update ()
        {
            _timer += Time.deltaTime;
    
            // Create a vector at the center of our camera's viewport
            Vector3 lineOrigin = _camera.ViewportToWorldPoint(new Vector3(0.5f, 0.5f, 0.0f));
    
            // Draw a line in the Scene View  from the point lineOrigin in the direction of fpsCam.transform.forward * weaponRange, using the color green
            Debug.DrawRay(lineOrigin, _camera.transform.forward * Range, Color.green);
    
            if (Input.GetMouseButton(0) && _timer >= ShootingDelay && !_isReloading && _currentAmmo > 0)
            {
                Shoot();
                if (!_isShooting)
                {
                    TriggerShootingAnimation();
                }
            }
            else if (!Input.GetMouseButton(0) || _currentAmmo <= 0)
            {
                StopShooting();
                if (_isShooting)
                {
                    TriggerShootingAnimation();
                }
            }
    
            if (Input.GetKeyDown(KeyCode.R))
            {
                StartReloading();
            }
        }
    
        private void StartReloading()
        {
            _animator.SetTrigger("DoReload");
            StopShooting();
            _isShooting = false;
            _isReloading = true;
        }
    
        private void TriggerShootingAnimation()
        {
            _isShooting = !_isShooting;
            _animator.SetTrigger("Shoot");
        }
    
        private void StopShooting()
        {
            _audioSource.Stop();
            _particle.Stop();
        }
    
        private void Shoot()
        {
            _timer = 0;
            Ray ray = _camera.ScreenPointToRay(Input.mousePosition);
            RaycastHit hit = new RaycastHit();
            _audioSource.Play();
            _particle.Play();
            _currentAmmo--;
            _screenManager.UpdateAmmoText(_currentAmmo, MaxAmmo);
    
            _lineRenderer.SetPosition(0, GunEndPoint.position);
            StartCoroutine(FireLine());
    
            if (Physics.Raycast(ray, out hit, Range, _shootableMask))
            {
                print("hit " + hit.collider.gameObject);
                _lineRenderer.SetPosition(1, hit.point);
                EnemyHealth health = hit.collider.GetComponent<EnemyHealth>();
                EnemyMovement enemyMovement = hit.collider.GetComponent<EnemyMovement>();
                print(health);
                if (enemyMovement != null)
                {
                    enemyMovement.KnockBack();
                }
                if (health != null)
                {
                    health.TakeDamage(1);
                }
            }
            else
            {
                _lineRenderer.SetPosition(1, ray.GetPoint(Range));
            }
        }
    
        private IEnumerator FireLine()
        {
            _lineRenderer.enabled = true;
    
            yield return ShootingDelay - 0.05f;
    
            _lineRenderer.enabled = false;
        }
    
        // called from the animation finished
        public void ReloadFinish()
        {
            _isReloading = false;
            _currentAmmo = MaxAmmo;
            _screenManager.UpdateAmmoText(_currentAmmo, MaxAmmo);
        }
    
        private void SetupSound()
        {
            _audioSource = gameObject.AddComponent<AudioSource>();
            _audioSource.volume = 0.2f;
            _audioSource.clip = ShotSfxClips;
        }
    
        public void GameOver()
        {
            _animator.SetTrigger("GameOver");
            StopShooting();
        }
    }

    New Variable Used

    None

    Walking Through the Code

    For our code change this time, we only added a new public function: GameOver().

    We do 2 things:

    1. We call our GameOver trigger to stop our shooting state
    2. We re-use StopShooting() to stop the particle and sound effects.

    GameOver() is a public function so that means it can be called from somewhere external, in this case, our GameManager script.

    Step 2.3: Calling GameOver() from PlayerShootingController in GameManager

    Now that we have the code to stop our player from shooting when the game is over, it’s time to use it in our GameManager.

    Here are our changes:

    using UnityEngine;
    
    public class GameManager : MonoBehaviour
    {
        public Animator GameOverAnimator;
        public Animator VictoryAnimator;
    
        private GameObject _player;
        private SpawnManager _spawnManager;
        private ScoreManager _scoreManager;
    
        void Start()
        {
            _player = GameObject.FindGameObjectWithTag("Player");
            _spawnManager = GetComponentInChildren<SpawnManager>();
            _scoreManager = GetComponent<ScoreManager>();
        }
    
        public void GameOver()
        {
            GameOverAnimator.SetBool("IsGameOver", true);
            DisableGame();
            _spawnManager.DisableAllEnemies();
        }
    
        public void Victory()
        {
            VictoryAnimator.SetBool("IsGameOver", true);
            DisableGame();
        }
    
        private void DisableGame()
        {
            _player.GetComponent<PlayerController>().enabled = false;
            _player.GetComponentInChildren<MouseCameraContoller>().enabled = false;
    
            PlayerShootingController shootingController = _player.GetComponentInChildren<PlayerShootingController>();
            shootingController.GameOver();
            shootingController.enabled = false;
    
            Cursor.lockState = CursorLockMode.None;
            _scoreManager.GameOver();
        }
    }

    New Variables Used

    None

    Walking Through the Code

    Everything is already in place, the only thing we want to change is inside DisableGame().

    Specifically, instead of just disabling our PlayerShootingController that we already had, we made sure that we called GameOver() and then we disable it to prevent any new user inputs/

    Conclusion

    With all of this in place, our game is 1 step closer to completion!

    Today we made it so that we would stop counting our time when the game is over and we solved an annoying bug that would have the player constantly firing when the game is over.

    That’s it for day 31! I think for day 32, we’ll look into creating a high score system and displaying that in our game!

    Look forward to it!

    Source: Day 31

    Visit the 100 Days of Unity VR Development main page.

    Visit our Homepage

  2. Adding some finishing touches to game:

    • Zombies now does not ignore player
    • Less annoying audio that fades away quicker when player is not close
      • Audio is far from done, ambient, footsteps etc...
    • New Zombie animations
      • Running
      • Standing up after being turned to zombie
    • Trees now hides when it obstructs view to player
    • Limited ammo and "realistic" clip-size and reload
    • Ammo crates
    • Minimap!
      • Cyan for human
      • Red for zombie
      • Gray for dead (really dead)
      • Yellow for ammo crates
    • Money-balancing
      • Killing zombie gives 10€
      • Killing human takes away 5€
      • Turret costs 500€
      • If Zombie kills human, it does not decrease money. Only if player shoots human, it decreases.
    • UI-redesign
    • Random details on maps (rocks, bushes and so on)
  3. Description; I am a designer currently working on the video game Colony 7. The purpose of the blog is to address the issues of the game's development and to address any solutions or alternative methods to better prepare for the arrival of inconveniences in the future or how to avoid them entirely. The blog also addresses my individual performance. The team is made up of two programmers and four level designers but all do not necessarily combine roles during development. The game is being developed in Unity (2017.1.1f1 onward) with a development time of 13 weeks for a college allocated task.

    Previously the team discovered that Unity's sharing capability (Unity Collaborate) was disabling code and the intended implementation of the assets created and placed into the project causing 'colliders' on each object to conflict with each other when connected via our custom kit pieces. To solve the issue my team decided to create one distinct project that would serve as the complete copy of Colony 7. We also agreed upon, when necessary, finalising the complete copy of the game when together and distributing that project amongst each other before departing for the week. I did not have much influence in the resolution to this encountered issue but did make suggestions based on previous experience. I have encountered trouble with Unity Collaborate previously and am unsure how to approach using it correctly and understanding why projects may conflict with other versions despite not having any errors on the initial device. If code specifically were transferred in person from device to device then issues would be expected to be resolved with the exception of the project on Unity not being current with it's most developed copy.

    My team is using the program MagicaVoxel to create almost all assets (and all aesthetic assets) for Colony 7. Placing the exported files as an 'obj' from MagicaVoxel from my own device would always display the correct colour scheme that I had designed and selected in the initial program. However retrieving objects created by other members of my team from places including Google Drive and USB transfer would display objects defaulted to one colour with their additional image being of no use to the asset. A fellow designer managed to figure out that the Albedo function of the 'material' of the object in Unity was the disrupted aspect. By placing the image featuring the intended colour scheme could be added to the object. I identified the complication of the asset issue first and the solution discovered was the only preferable way to solve the issue in a short amount of time. Due to my designated role of asset creation I have not had any impact toward understanding how Colony 7 will form together as final product. MagicaVoxel being the program I have most used thus far has limited my chances to learn about other functions in the coding and implementation of my assets. Spending time with each team member and having them each explain their role and actions during development time would be beneficial in involving me in positions I can undertake and perform tasks not suited to me but needed,

    -

    These two problems encountered were the main disruptions my team encountered and we were able to solve with little cost to our development or time management. Individually I was able to point out the problems and make suggestions on how to best correct them both but I did perform greatly in solving the issues themselves. These were both things met during the early development of Colony 7 however.

    More unexpected halts in progression will be addressed with future blogs throughout Colony 7's development time. Thank you for your time and feedback is appreciated.

    Colony 7 Designer.

  4. The #coloredWoman video is planned to be published on Halloween, so we are totally focused on cutting and perfecting her moves and style. (see pics below)

    Her hair, her face, her colors, her moves: the colored woman is determinded to be perfect while all these cameras are scanning her entire hot body from all perspectives.

    The #coloredWomanSong is also finished and will be played as musical background in the #coloredWoman video.

    The face of main-character Charly Clearwater is completely modeled, too. His bones are installed and he is waiting for his subsequent processing after Halloween.

    We have also decided to write more detailed technical blog entries , now and then, e.g. about how we made the whole colored woman video from the technical point of view.

    See you on Halloween, hopefully!

     

     

  5. Hello and welcome to my new Sound Effects Website: http://www.ogsoundfx.com

    Download this Sound Effect pack for free!

    http://www.ogsoundfx.com/product/og-sound-fx-free-samples-sounds-loops/

    It includes 17 tracks of guns, explosions, underground atmospheres, medieval town atmosphere and more !

     

  6. Oh boy, it’s that time of year again where all of my terminal settings get reset!  Thanks, Windows 10 Fall Creators Update!

    terminal-before.png.25dde56b4106a27529699bf2880dc529.png

     

    But this time, I’m prepared !!
     

    I’ve made some adjustments to my previous attempt to Unify Windows 10 Terminal Settings.  Namely, I’ve fixed the ACL not working as expected.  Apparently `set-acl` attempts to reset the owner, which is denied when also removing the write permission.  Additionally, the ACL needs to be reloaded in order to get the correct converted ACLs from the item’s parents.  The workaround is as follows:

    # deny current user write permissions
    $item = get-item $path;
    $acl = $item.GetAccessControl('access');     # https://stackoverflow.com/a/6646551
    $acl.SetAccessRuleProtection($true, $true);  # Disable inheritance, assume inherited
    $item.SetAccessControl($acl);
    
    $acl = $item.GetAccessControl('access');     # Reload ACL to obtain inherited permissions
    $acl.RemoveAccessRuleAll($rule);             # Remove existing rules for the user
    $acl.AddAccessRule($rule);
    $item.SetAccessControl($acl);

     

    I’ve also added back in the registry fix:

    $console = (get-item HKCU:\).OpenSubKey("Console", $true)
    $console.GetSubKeyNames() |% {
    if ( $pscmdlet.ShouldProcess($_, "Remove Subkey") ) {
    	$console.DeleteSubKey($_);
    }

    And after running:

    remove-consoleprops -StartMenu -AdjustPermissions -Registry -ErrorAction Continue

    … I was pleased to see that it worked as expected!

    terminal-after.png.84f1fa24d11036602930716baa7ee1ac.png

    I will be working toward publishing these scripts as a GitHub gist, so these files are versioned and others can contribute.

    That’s all for now.  Thanks for reading; see you around!

    :^)

  7. Little over a month ago, some guy noticed me by my nickname on another website (I use Embassy of Time several places), and asked if I was the one who also posted on GameDev. I said yes. Apparently, he was amongst those reading my scientific ramblings (like this or this) on the site. And he also happened to be a small-time member of a network of personal investors, so-called "business angels". Now, I've run a company before (web TV and 3D animation, not game development), so I know that a lot of people make big claims, and even if those claims are true, you don't win the lottery from just being noticed. But it was an interesting talk.

    Then, about a week ago, he contacted me again. A couple of his colleagues (I have no idea what investors call each other) wanted to see a project suggestion on some of the things we talked about. Part of why they wanted to see this was that they had a look at my blog in here and wanted to know more. So now, I am working on a presentation of some of the things I have worked with on a serious science-based game. I am pretty nervous, and very open to ideas from people in here on how to dazzle these folks!

    It's not a big blog entry this time, I know, but I felt like letting people here know, and giving a big thanks to GameDev.net for being a community where some lunatic with a science fetish (me) has a chance to get noticed! If this works out well, I definitely won't forget you ;)

  8. I've been working on the node graph editor for noise functions in the context of the Urho3D-based Terrain Editor I have been working on. It's a thing that I work on every so often, when I'm not working on Goblinson Crusoe or when I don't have a whole lot of other things going on. Lately, it's been mostly UI stuff plus the node graph stuff. The thing is getting pretty useful, although it is still FAR from polished, and a lot of stuff is still just broken.

    Today, I worked on code to allow me to build and maintain a node graph library. The editor has a tool, as mentioned in the previous entry, to allow me to use a visual node graph system to edit and construct chains/trees/graphs of noise functions. These functions can be pretty complex:

    70xCrMd.png

    I'm working on code to allow me to save these graphs as they are, and also to save them as Library Nodes. Saving a graph as a Library Node works slightly differently than just saving the node chain. Saving it as a Library Node allows you to import the entire thing as a single 'black box' node. In the above graph, I have a fairly complex setup with a cellular function distorted by a couple of billow fractals. In the upper left corner are some constant and seed nodes, explicitly declared. Each node has a number of inputs that can receive a connection. If there is no connection, when the graph is traversed to build the function, those inputs are 'hardwired' to the constant value they are set to. But if you wire up an explicit seed or constant node to an input, then when the graph is saved as a Library Node, those explicit constants/seeds will be converted to the input parameters for a custom node representing the function. For example, the custom node for the above graph looks like this:

    h5X6wLF.png

    Any parameter to which a constant node was attached is now tweakable, while the rest of the graph node is an internal structure that the user can not edit. By linking the desired inputs with a constant or seed node, they become the customizable inputs of a new node type.

    (A note on the difference between Constant and Seed. They are basically the same thing: a number. Any input can receive either a constant or a seed or any chain of constants, seeds, and functions. However, there are special function types such as Seeder and Fractal which can iterate a function graph and modify the value of any seed functions. This is used, for example, to re-seed the various octaves of a fractal with different seeds to use different noise patterns. Seeder lets you re-use a node or node chain with different seeds for each use. Only nodes that are marked as Seed will be altered.)

    With the node graph library functionality, it will be possible to construct a node graph and save it for later, useful for certain commonly-used patterns that are time-consuming to set up, which pretty much describes any node graph using domain turbulence.

    With that node chain in hand, it is easy enough to output the function to the heightmap:

    eBOmKpe.jpg

    Then you can quickly apply the erosion filter to it:

    D2oAHnC.jpg

    Follow that up with a quick Cliffify filter to set cliffs:

    WhASGoV.jpg

    And finish it off with a cavity map filter to place sediment in the cavities:

    pzY6ey4.jpg

    The editor now lets you zoom the camera all the way in with the scroll wheel, then when on the ground you can use WASD to rove around the map seeing what it looks like from the ground.

    v0IOTtR.jpg

    Still lots to do on this, such as, you know, actually saving the node graph to file. but already it's pretty fun to play with.

  9. Welcome to this week’s From the Forum. In this post, we highlight a few Corona Community Forums posts that cover important topics.

    Building rooms

    Corona developer extraordinaire Alex@Panc posted this fantastic informational post on how to generate rooms procedurally using the Binary Space Partitioning Tree method. If you want to generate rooms for a dungeon or other map methods, this will be worth your time to read.

    Bouncing around

    Physics collisions can be tricky to implement when you want to have full control over the interaction between objects. Roaminggamer does a great job explaining how static, dynamic and kinematic objects interact with each other in this thread.

    Range to target

    In this thread, a developer wants to know how to increase the distance between objects that are related to each other. Our community came together and offered up some great suggestions and code to help with the problem.


    Do you have a particular forum thread that was helpful for you? Let us know about it! Email support@coronalabs.com, put FTF: and the forum title in the subject, and include the URL in the email. We will consider adding it to an upcoming edition of From the Forum.


    View the full article

  10. Finalspace
    Latest Entry

    I am making steady progress - but in a very slow pace, not sure if i can keep up with the challenge time frame.

    Also i am coding on my crappy notebook (MSI Apache Pro) with the worst keyboard layout ever. No space for a keyboard right now, also i am sick fighting against a cold.

     

    Evening 4:

    Game pad input is working great, thanks to XInput with integration into FPL ;-)

    I can plug in and out any controller and it just works. Also i prepared it for multiplayer, so it will spawn another player when a new controller has been plugged in. When i am in single player mode, every controller can control the single player. So you can move with the keyboard and then of a sudden switch to a gamepad and move with them. Pretty cool if i say that so myself.

     

    Evening 5:

    Starting to get a basic level editor up and running, with the ability to toggle between editor and game mode.

    Also i changed the renderer system a lot.

     

    Evening 6:

    Struggling a lot, lost a bit of motivation but still made some progress.

    Now i am rendering sprites for the level instead of rectangles, yay! Also i integrated ImGui now and made the editor entirely with the ImGui API.

    Worked beutifully after i nailed down some simple dimensional math... which took me forever, because i suck at math most of the times because i am not using it regularly.

    Game is still the same though... simple stable platformer, but no enemies, no collectibles, no goal... 

     

    TODO:

    - I need to make a player sprite, a rectangle looks ugly

    - Time to make my first enemy for the very first time, i never made any AI code at all

    - Player should fire something to freeze the enemies, but with a cooldown

    - After sprites are done, make animations and integrate it into the game.

    - Sounds

    - Menu

    - More levels

     

    gd201710_shot2.png

  11. Special Promotion - 1 Week Left!

    We have a special promotion running until October 31st, where you can win FREE* game or app localization - a $150 value! (*3 languages of your choosing, up to 200 words)

    All you have to do is:

    1. Follow LAI Global Game Services on Twitter (or Facebook) & RT (or Share) the contest announcement
    2. Download the Game Market Analyzer
    3. Send us your feedback at gma@lai.com!

    Thanks for helping us make this free tool better, for game and app developers!

    DL6vIJJVAAEtips.jpg:large

     

    Who is LAI Global Game Services?

    LAI Global Game Services is a veteran game localization, voiceover and games publishing team, with 25 years of experience localizing games for AAA and indie developers.

     

    A Small Sampling of Our Clients: Sony, Ubisoft, Level Up!, Havok

    Past Projects: Sony's Wild Arms 2 (PS), Ubisoft's Lunar Genesis (DS), Ubisoft's Enchanted Arms (PS2), parts of SUPERHOT (PC)

    GMA-LAI-Casual-Connect-Game-Market-Analyzer-App-Only-Free-Tool-ROI-Predictor.png

     

    Questions about Localization or Games Publishing?

    Ask our CEO on our upcoming Reddit IAMA - Friday, October 20th, 2017!

    Chat with us 10amPST/1pmEST/5pmGMT.

    ask_me_anything_reddit_logo.png

  12. Hi, everyone!

    This time we came here to call for your help to make our Indiegogo Campaign great! On November 1st we will launch our Indiegogo Campaign for the game "The Gragons Farm". And we want all of your help and support to reach our final goal of releasing The Gragons Farm.

    The Gragons Farm | Pre-Launch Indiegogo Campaign

     

    Indiegogo Pre-Launch Campaign

    Today we show you our Pre-Launch Campaign. This Pre-Launch Campaign shows a little bit about what the full Campaign will be like. We have a lot to show.

    In the full campaign we have lots of different goals to reach, for example Marriage and Children, Gragon Breeding, NPC Quests, and much more. If you help us reach this goals, we together can make the game we all want. If we reach all the goals, we have a big surprise to show you, but only if we reach all the goals.

    On the full Campaign we will have lots of different Rewards/Perks to choose, for example, Digital Cards, Wallpapers, Digital Books, Name on Credits and much more.

    Join Up on our Pre-Launch Campaign to receive de latest news and activities about the campaign and about The Gragons Farm.

    Click on the link below to Join Up now with your email.

    IndiegogoCampaign

    Join Up now before the launch to get a Free Digital Gragon Card! There are 100 different cards, you get 1 random card.

     

    Card Background

     

     

    Full Campaign on November 1st

    We want you to be part of The Gragons Farm, so on November 1st, we want you to join us on Indiegogo Campaign to earn lots of different Rewards and help us make the game you truly want.

    CampanhaIndiegogoIngles

     

    That´s all for now. We need all the feedback possible to create the game you want.

    If you have questions to ask, ideas to tell us, just email to voidjogos@gmail.com.

    Note: This game is a Beta Demo and the full version is still in development.

    Links

    Visit our Itch.io page to download the Beta Demo

     

    Visit our VoidJogos Facebook page to see what we are doing and contact our team and also Like the page.

    Facebook

     

    Visit our VoidJogos Youtube Channel and Subscribe to see all the latest videos.

    Youtube

  13. Hi everyone!

    Sorry we didn’t post this yesterday but we’ve been quite busy ahah, yet we don’t have much to say! (struggling)

    Customization Feature

    I know we have been on and on about this but it should be almost finished! At least we think the coding is part is done YAY! And now all we need is to place the right rig (skelethon) in all the clothes models and it should be finished! Party ahah!

    Techdays

    Teresa was at Techdays, a technology expo in Aveiro, Portugal. Where about 50 companies gathered to show their products and services. Teresa was there for 3 days showing Project SpaceVille to people, and they had a lot of fun!

     

    731331_208a5dfb74e449fca6bfc44af3252b4e~

     

    We promise to have more a more interesting theme to talk about on our next devlog! :)

    Cya next week!

     

    The FAXIME Team

    http://www.reactiongifs.us/wp-content/uploads/2015/04/nothing_to_see_here_naked_gun.gif

     

    Follow us and keep updated at:

    Facebook: https://www.facebook.com/FaximeGames

    Instagram: https://www.instagram.com/faximegames

    Twitter: https://twitter.com/FaximeGames

    Pintrest: https://www.pinterest.pt/faximegames

    SoundCloud: https://soundcloud.com/faximegames

  14. should flatter to senior employees or employers , should join after-working dining together , should do singing well at employdickheads EVERYDAY

    this is a disaster , no techs no passions are here. just fucked up with horribly low salary.

  15. Our first Improvement was an Item tag system.  Each color represents a Grade. (F = Red, D = Yellow, C = Green,  B = Cyan, A = Blue, S = Pink) These are place holder colors but they don't look to bad.

    59e6afcebd108_ezgif.com-video-to-gif(3).gif.997ce53361f2a967b998f755865d5bde.gif

    Second We have a new Item interface. which is accesses with a double click.  It dynamically populates the options based on the Item, E.G for a tool or seed the item would equip it to your hand. If the item was consumable, the buttons label would read "Eat" and it would be consumed instead of equipped. 

    omg.png.14d4fa21f799f062568c6548af6d90cc.png

    and Finally the Item information Panel.

    omgs.png.c908aa064ad9a30a781c4c172b6da770.png

     

    Like it, hate it? Let me know in the comments below. 

     

    —Brua-1589.

  16. Part 1

    1. It needs to work. And by work I mean execute without crashing.
    2. It needs to do what you expect it to do.
    3. It needs to have code you can actually read and debug.

    Part 2

    • No Syntax Errors
    • No Warnings (from the compiler)
    • It has tests (yes, even asserts)
    • It passes test.
    • It logs errors.
    • It does not crash.
    • Someone who doesn't know you won't kill you for writing completely illegible code.
    • It has instructions. For the user.

     

  17. augmented-reality-services-goodworklabs.

    Augmented reality now is so intricately woven into everyday living and entertainment. Games, movies and even tattoo parlors make use of augmented reality apps. You most likely would have heard of the world-famous game Pokémon Go, and the massive reception it received worldwide. Do you want to know why it was such a massive success? Gamers will tell you that the more real a game is the better its reception. In other words, the closer to real life the game characters are, the more interesting the game becomes. Pokémon Go achieved that, it gave us fantasy characters that we could chase and capture like real life characters, and augmented reality was the backbone of its success.

    With the success of Pokémon Go and other augmented reality apps and games, you may start to wonder how the mobile app development company came up with the awesome idea that so many people come to enjoy. Well, a lot of things come to play in bringing augmented reality to life and not just any life, a successful one, and every mobile app development company realizes that all of the features of their app will have to be more than satisfactory to be successful. To begin we will consider some features that augmented reality apps should possess to garner some measure of success in the market.

    GPS Functionality

    Most devices come with the option of turning on location, an augmented reality app should be able to work with this already pre-installed GPS and work seamlessly with it. It will be cumbersome and redundant to build an app that will have its own GPS locator. Building an app with its own GPS locator will not be necessary if the app can make use of that on the device. Pokémon Go would not have been such a success if it was not able to work in real time with the device’s GPS.

    Real-Time Rendering

    This is a must for all augmented reality apps and every ar app development company knows that for its app to be widely accepted there should be no time lag between processing information(could be space, picture or location) and rendering. Take, for example, google translate; just taking a picture of the phrase, word or sentence you want to translate and feeding it into the app gives you the translation into the required language in real time. It can even go ahead and pronounce the translation for you. Imagine how tiring it will be if Google had to search for about 5 minutes to come up with that translation. This point cannot be overemphasized.

    Good Spatial Recognition

    Some apps are used for trying to fit wares, furniture or items into space. For example Augment, an app used to show customers real-life representation of their purchases. This app can also place the purchased item in different locations in the house so that the customer will be able to see just how the purchased item will fit into his home or office setting. Imagine trying to place a vase you bought online on your reading table, and because of poor spatial recognition, the vase keeps overlapping with your side table instead of sitting on it, that will be utterly ridiculous. So for augmented reality apps to be of any use whatsoever, these apps should have good spatial recognition.

    Ease of Use

    The more complex running an app is, the more useless the app becomes to the customer or users. On the other hand, the more ease in using an app, the more effective it becomes to the user. If users have to provide complex or numerous parameters before the app works, then it serves no purpose but to annoy the users. Augmented reality apps should be as close to plug and play as possible. Consider the augmented tattoo app Ink Hunter, for example, it does not require you to draw up complex designs of your own or provide some other complex information before giving you beautiful tattoo renderings. The app is able to work without the need for such data. It simply renders the image on the skin of the customer allowing the customer to see what the actual tattoo will look like eventually.

    Be Social

    The more social an augmented reality app is, the more it has to offer to the user. Pokémon Go had this feature and it proved to be a major selling point for the augmented reality game. The game offered the chance of joining teams once a certain level had been reached. A sense of camaraderie can be helpful for the user. And surprisingly most users looked forward to these social interactions. Some apps offer the users the opportunity of dropping messages at different locations, these messages can be read by other users of the app if it marked public or by specific users if the message is marked private.

    Entertaining

    No one wants a boring app, least of all, a boring augmented reality app. If the app is not entertaining to use, there is really no need for even creating such an app. It must be noted that this feature does not apply to augmented reality game apps alone. Regardless of the purpose for which the app was created, its users should get excited whenever they use the app. This is a must for every app. Every experience the user has with the app should be an exciting one. For example, there is an all that helps in arranging furniture in an apartment. It will be entertaining to keep placing and then moving furniture till you get the best location. Entertaining will also mean that the users should feel like they’re a part of the experience. They should also be able to relate to certain aspects of the app.

    Pokémon was a part of most gamers childhood, so it was quite easy for them to relate to the augmented reality version. This seems quite basic, but it can greatly affect the reception that your app will receive.

    Universal

    If possible, the ar app development company should try to build an app that will be available for both iOS and Android users. It makes no sense to restrict your apps usage to users of a particular operating system. When the app works across both operating systems, the company will have won users on both sides. On the other hand, if the app discriminates against some users of a particular operating system, it shuts those users off and the potential market too. It will be more useful if it is possible to release most apps across both operating systems.

  18. Just 5 days left till release !

    Take  a look at Best Actions Montage From Yesterday's Play Session:

    https://www.facebook.com/bouncybobgame/videos/927268027431229/

  19. NEW MUSIC (OBSCURITY)

    Originally posted on FidelumGames.WordPress.com on October 1st, 2017

    Here comes Obscurity!

    This was the first song I made for The Wayfarer. I actually did intend to do something a bit (a lot) brighter, but at times you really can’t really control what comes out. smiley And since I liked how it sounded and felt, I kept doing it until it was ready. And I’m glad I did.

    If all goes as planned, during the next week I should be getting a new pair of stands for my Behringer Truth B2030A monitors. After that I can direct these studio monitors correcly, which should have a positive impact to mix quality.
    For now they have been positioned strongly asymmentrically, so they are next to useless during mixing, and 99% of the work has been done with headphones. That 1% is the last rouch check if there are any frequencies that come through in piercingly strong way.

    Can’t wait to have them.

    BR

    Mika Pilke

    HURRAH! MILESTONE #1 REACHED

    Originally posted on FidelumGames.WordPress.com on October 13th, 2017

    First off:

    YAY!

    I’ve reached my first major milestone in the development of The Wayfarer. My enemies (as far as behavior goes) are complete! They still need to be replaced with proper models and given the ability to die (along with dropping loot, etc.), but all of the AI and related systems are complete and, as far as I can tell, mostly bug free.

    I think that, in order to stay motivated, it’s important to celebrate these small successes, so last night I had a few drinks, and today I’m writing this post and giving myself a pat on the back (good job, me).

    So why did I decide that this was my first major milestone?

    In my development experience thus far, one of the hardest and most frustrating things I’ve found is the difficult and delicate act of creating and maintaining complex interconnected systems.

    All of the individual items I’ve completed so far for my enemies (attacking, spellcasting, navigation, stats, decision making, editor tools, etc.) have not been overly difficult to implement individually. Sure, there were some challenges, but nothing too major. The real challenge is making all of these things fit together in a way that they all still work, and doing so in a way that makes sense and doesn’t cause terror when thinking about having to change something.

    The reason I’m considering this to be my first major milestone is because all of the features mentioned above, even though they’re all individual systems, are now combined into a larger closed system. This means that I know each individual system works, and I know they all work together, and the stress of having to make that a reality is gone! Moving forward, I can start working on smaller systems again (like player actions, looting, inventory management, levelling, etc.), which is a quicker, simpler and more carefree process than integrating said systems.

    Of course, once those individual systems are done, I’ll have to integrate them into another closed system, thus reaching another milestone. But, to keep myself realistic, and to prepare myself for the difficulties to come, I do realize that once ‘closed’ system number two is complete, I’ll have to connect it to closed system number one.

    I have no experience working with systems on this scale, so this is a huge learning experience for me, and I don’t know what to expect. Part of me is expecting the worst, another part is optimistic and hopeful that I’ve paid my dues in terms of keeping the code clean and sensible, and should reap the benefits when the time to integrate comes.

    Anyhow, I’m super pleased and happy at the moment, and can’t wait to start working on new features again. Hopefully things go smoothly for the next little while and these posts will start getting a little more frequent.

    This was a huge hill to climb, and I’m glad to be at the top of it (even though I can see the top of the much larger hill in the distance).

    SQUISHING MAGICAL BUGS

    During most of my last five or so development sessions, I felt I was making very little progress.

    I had my spell system pretty much complete, but the process for creating new spells had become too in depth and complicated, so I had to redesign some things and make some pretty major changes.

    Originally, I had been using ScriptableObjects for my spells, and while it was cool, and made me feel like a ‘real game developer’ to be able to create a spell by clicking Asset>Create>New Spell in the Unity editor, it just wasn’t practical for my purposes.

    I wound up sticking with trusty ol’ prefabs in the end. While the new system isn’t as generic as the old one (visual effects are now part of the actual spell prefab), it’s much more friendly and maintainable, and I’m able to create new spells in a matter of just a minute or two (not counting VFX creating time).

    Reworking this system was fairly straightforward. What really sapped my motivation and frustrated me was a bug that I just couldn’t squash.

    Many of the spells in the game will apply buffs to the caster, or to the caster’s enemy. These buffs have the ability to fortify or weaken any stat that exists in the game, and, when being used by an enemy, who the buff is being cast on (self or enemy), is important.

    I’ve designed my AI in such a way that, after it has decided to cast a spell, it chooses one at random, filtering out any spells that aren’t available to be cast. I’ve defined a spell that’s unavailable as one which:

    1. Has a range less than the distance between the caster and the target
    2. Costs more mana than the caster has available
    3. Added a buff to the caster which is still active

    The most important item on this list, in terms of the bug I’m about to describe, is number 3. I don’t want my enemies ‘wasting’ a turn by casting a buff on themselves which they’re already benefitting from. However, enemies are fully ably to cast the same buff on the player multiple times.

    The caveat with this, however, is that I don’t want multiple buff casts on the player from the enemy to stack. Instead, I want a re-casted buff to reset the remaining turn duration of the buff on the player.

    The exact opposite was happening–the buff was stacking leading to a spell which should cause a -2 to strength to be able to cause a -10 (or whatever other number) instead. Additionally, this was causing the player’s stat to increase when the buff wore off.

    This was a relatively small bug, but it drove me absolutely bonkers. Like I said, I spent somewhere around five sessions trying to fix it, getting little else done.

    Here’s the original method which caused the problem: 

        public void AddActiveBuff(Spell spell) {
            foreach (StatusEffect buff in spell.StatusEffects) {
                if (!IsBuffActive(buff)) {
                    activeBuffs.Add(buff, spell.Duration);
                    stats.AddStatModifier(buff.stat, buff.amount);
                } else {
                    activeBuffs[buff] = spell.Duration;
                }
            }
        }

    Can you spot the error?

    I’ll give you a hint: I use a Dictionary to store my activeBuffs, where they key is a StatusEffect object (the contents are unimportant), and the value is an integer representing the number of turns remaining for the buff.

    I fiddled with this friggin’ thing forever. I changed how I stored my activeBuffs, considered adding some polymorphism to my Spell class, creating multiple arrays to store the data–all kinds of things. In the end, I commented out a single line on a whim, and found the problem:

     

        public void AddActiveBuff(Spell spell) {
            foreach (StatusEffect buff in spell.StatusEffects) {
                if (!IsBuffActive(buff)) {
                    activeBuffs.Add(buff, spell.Duration);
                    stats.AddStatModifier(buff.stat, buff.amount);
                } else {
                    //activeBuffs[buff] = spell.Duration;
                }
            }
        }

    Yep. One line of code. Seems to always be the cause of these tricky bugs.

    Because my spells are prefabs, the StatusEffect objects attached to them are instances belonging to the instance of the Spell when cast. Therefore, because the key in my activeBuffs Dictionary is an instance of a StatusEffect (something I overlooked, foolishly thinking that two separate but identical StatusEffect instances would be equal), I was adding a new entry to the activeBuffs Dictionary with the above commented line, rather than just resetting the duration of the existing entry.

    Of course, when I discovered this, I shook my head, and solved the problem in about thirty seconds by comparing buff names rather than objects: 

    public void AddActiveBuff(Spell spell) {
            foreach (StatusEffect buff in spell.StatusEffects) {
                if (!IsBuffActive(buff)) {
                    activeBuffs.Add(buff, spell.Duration);
                    stats.AddStatModifier(buff.stat, buff.amount);
                } else {
                    foreach (StatusEffect activeBuff in activeBuffs.Keys) {
                        if (activeBuff.name == buff.name) {
                            activeBuffs[activeBuff] = spell.Duration;
                        }
                    }
                }
            }
        }

    Once that was done, I was able to move on to fixing another small bug with my custom Stat inspectors, decide not to make another change regarding how buffs decay (a concern caused by the bug) and add a small piece of code that ignores the turn system when the player is not in combat (allowing for quicker exploration).

    Once those items were done, I suddenly realized that I had actually reached my first milestone and the frustration and lack of motivation I had been experiencing transformed into excitement and vigor.

    One more time:

    YAY!

    WHAT’S NEXT

    With that cumbersome set of tasks out of the way, what’s next?

    Well here’s what my task list has to say:

    1.3.    Milestone 1 Wrap Up – Complete Basic Turn Based System In Progress
    1.3.1. Refactor and clean-up existing code  
    1.3.2. Document all existing features – UML, GDD, Code Comments  
    1.3.3. Celebrate! In progress
    1.3.3.1.              Have a few drinks (YAY!) Complete
    1.3.3.2.              Celebratory blog post In Progress

    Yes, this is actually on my task list. These things are important!

    But, more technically, here’s what the rest of my task list looks like at the moment.

    1.4.    Player Combat Actions  
    1.4.1. Attacking  
    1.4.1.1.              Melee  
    1.4.1.1.1.                    Create Placeholder Weapon  
    1.4.1.1.1.1.   Attack Animations  
    1.4.1.1.1.2.   Damage Enemy  
    1.4.1.1.1.3.   Ranged (Spear, etc.)  
    1.4.1.2.         Ranged  
    1.1.1.2.1.                    Create Placeholder Weapon  
    1.4.1.2.1.1.   Define how moving projectiles affect turns On Hold/Tentative
    1.4.1.2.1.2.   Projectile Animation  
    1.4.1.2.1.3.   Magic  
    1.4.1.2.2.                    Casting Animation  
    1.4.1.2.2.1.   Implement  
    1.4.1.2.2.2.   Dual Wield? On Hold/Tentative
    1.4.1.2.3.                    Define how the player will use dual wield (Attack both at once, choose which hand, etc.) On Hold/Tentative
    1.5.    Define item types (Consumable, Weapon, Armor, Quest, etc.)  
    1.5.1.Define item script heirarchy  
    1.5.2.Determine item commonalities and differences  
    1.5.2.1.              Create item hierarchy  
    1.5.2.2.              Weapons  
    1.5.2.3.              Create Weapon Scriptable Object  
    1.5.2.3.1.                    Make Weapons equippable (through editor)  
    1.5.2.3.2.                    Share common animation based on type  
    1.5.2.3.2.1.   Practice with Infinity Weapons  
    1.5.2.3.3.                    Practice with Mesh Effects  
    1.5.2.3.4.                    Integrate Infinity Weapons and Mesh Effects  
    1.5.2.3.5.                    Procedural Weapons  
    1.5.2.3.5.1.   Experiment with Infinity Weapons texture generation and Blend Shapes at Runtime  

    I made these items quite a while ago now, so the list will change before I actually start working, but this will give you a general idea of what I’ll be working on.

    The On Hold/Tentative items are ones that might not be needed, or that I have yet to fully decide to include in the game.

    POSSIBLE NAME CHANGE

    The last thing I’ll mention is that I’m considering changing the name of the game. I really like the title The Wayfarer; I think it sums up what the experience is essentially about. However, performing a search for the title, it seems too common a name.

    The first page of Google alone is filled with restaurant pages, and there are even a couple of games already existing with names similar to The Wayfarer.

    On the other hand, performing a search for my last game Pixel Zombie Shooter brings it back as the top result, and The Wayfarer has a much larger online presence than Pixel Zombie Shooter as far as all of the blog posts, Youtube videos, etc.

    So, I think that if I’m going to change it, I should do it sooner rather than later. What are your thoughts? Anyone with marketing experience want to chime in?

  20. In this daily blog (and video)-series I take a first impressions look at the best mobile games that I come by. Be sure to share your favorite mobile game with the rest of us in the comments below!

    Snakebird is a visually appealing but mind(bird)-bending puzzler where the first 10 levels are free and a single IAP unlocks the full game (45+ levels). 

    The main reason I recommend Snakebird, however, is because of the great level-design, with each level represents an entirely new puzzle challenge.

    My thoughts on Snakebird:


    Google Play: https://play.google.com/store/apps/details?id=com.NoumenonGames.SnakeBird_Touch&hl=en
    iOS: https://itunes.apple.com/us/app/snakebird/id1087075743?mt=8

    Subscribe on YouTube for more commentaries: https://goo.gl/xKhGjh
    Or join me on Facebook: https://www.facebook.com/mobilegamefan/
    Or Instagram: https://www.instagram.com/nimblethoryt/
    Or Twitter: https://twitter.com/nimblethor

  21. In the monthly progress post I figured I needed a Game Design Document (GDD) before working on extra features. It would be a waste of time working on features when I have no clearer picture where the game should evolve to.

     

    The first thing I did was searching for online resources. I have found a bunch, and decided to share those on a page dedicated to Game Development Resources for other game developers.

     

    While working on the GDD I noticed it takes quite a lot of time and it is easy to get lost into details for a long time.

     

    Then, after a week or so, I came into contact with a guy named Richie and he had the tip that I had to scope my game into 5 minutes of gameplay.

     

    So in 5 minutes, the player has to know:

    • what the game is about
    • the basic mechanics
    • if it is fun to play

     

    With that I began to look at the GDD I made so far. I immediately noticed that I had way too much material for 5 minutes of gameplay. Obviously this is because a RTS game has several phases. It would be easy to discard the 5 minute thing, but I wanted to follow it though: what would be the essence, the end goal of the game?

     

    Together with Dorus Verhoeckx, someone I work with together on our own products and dreams, I started stripping all stuff that might be ‘distracting’ from the main objective. This meant base building is minimized (2 buildings left). Resource gathering was cut – just get money from structures. Have only 1 unit type. Etc.

     

    This was done on paper. A lot of stuff stripped and the core objective exposed. Then I started writing down what was left to do to get this into a working prototype:

    IMG_8286-300x225.jpgPrototype, with todo’s on the right. Lots of the has been crossed, since I worked on them lately 🙂

     

     

    So what is the essence? Domination in RTS games. Conquer specific structures, hold out long enough to score domination points. Resource gathering? I ditched that in favor of getting money for specific captured structures. (not all captured structures give you ‘domination points’ though). You play 5 rounds of 1 minute. After 5 rounds – the player with the most domination points wins!

     

    Is it a good idea? Is it fun? What about all the other cool stuff I wanted in my RTS game?

     

    Well lets first see to finish the prototype – I want to get it out before the end of the month. I’d love to hear how you guys think about this kind of game. And if you’re interested in testing out the prototype just let me know at stefan[at]indienamic.com. Then, after that I will decide if I miss stuff, want to re-add things and further iterate. My expectation is that there will be quite some iterations / prototypes / refinements before the final ‘game’ mechanics are there.


    View the full article

  22. dyY6N3B6dLC0MkSxCJgK0e2s2H2DK9pHNCJs6-s5mYJyA1kM7kofukzvwCk6GSAcKCnMnu_c8gVSdouvdTbvy90Lq1-JfRqnm9r6BMVp0jAXwxapdvDy7tQAol3LqFSPkVYmYp9c

    Starting an outsourcing relationship is troublesome but how to make it more seamless? Tilting toward hiring an offshore software development company is obvious for cost reduction, high-quality software products, innovations but there are a great many of common risks setting your projects astray. The following questions are - “What are the challenges?” Let’s make everything as clear as a bell.

    Challenge #1: Lack of communication

    Developing a new software product is a tedious and social process involving lots of communication to share your ideas with the development team and discuss the app concepts. It’s quite arduous when your team is miles away since an efficient communication is a key to a successful app.

    Solution #1: Use the Internet

    Thanks to the Internet and its unlimited possibilities, long distances, and time differences aren’t a problem for modern entrepreneurs. You can use video conferencing, voice calls, emails to keep in touch with your app development team.

    Video Conferencing Services To Use

    Challenge #2: Loss of Control

    One of the biggest fears is the loss of visibility and control while outsourcing an offshore app development company. Communication problems and slow response may result in increasing the costs and time required to build an app.

    Solution #2: Track Working Time

    The key to eliminating the challenge is to manage the process carefully. Set weekly goals for the development team to ease the workflow and achieve better results.

    Time-Tracking Tools You Should Use

    Challenge #3: Language Problems

    One of the problems you may face while working with an offshore app development team is misunderstanding caused by lack of foreign language knowledge. Taking into account, the fact communication is truly vital to achieving success as an app entrepreneur.

    You may face difficulties with the communication as it may be restricted by the ability to speak a foreign language. For example, you’re living in the U.S. with English as your native language, but you decide to hire a French software development team. Though English is a modern lingua franca, only a limited number of people can speak well English.

    Solution #3: Study the Market

    To avoid that language misunderstanding, you should carefully select the country and the outsourcing vendor that have completed projects for foreign companies (and released them).gQozKtslKpemxey7uu-wWz_ZQfja0qvG3cvyamByd9DZ364JV0mdloT7lQp4BNDAlSTVVa7pcaRPed-urMPwTLenpECaTpVMFgYuGUHG3KVLqHfdqDfGSGFN5RJuxaX-gqaJXLQl

    Challenge #4: Low Quality

    Once you have your product on the track, you expect to get a fully-functioning application meeting all your needs and quality standards.The chances of low-quality code is increased when hiring an offshore software development company. If you get a bad code and poor app architecture, you get frustrated and pay more to get it re-written. Thus you pay twice as much to detect and fix the bugs. Along with the increased costs, it takes more time.

    Solution #4: Check the Company Before Hiring

    First and foremost, don’t get fooled by low hourly rates and never hire a company that you don’t know. Read the reviews, ask for a customer list. If the company refuses to provide a list of launched apps or clients contact data, I’d never outsource such a company. Check company’s profile on Clutch to make sure they can deliver a top-class software product.

    Challenge #5: Testing More Difficult

    Of course, testing an outsource project is more arduous when comparing on-site testing. If you test a product and find out it isn’t the app you wanted to get, this needs to be discussed with your offshore vendor. And the following may become a real problem as the vendor might not be able to understand and then fix the problem.

    Generally, it can be easily fixed when detected at the initial development stage and when the problem is improperly described and understood, this will result in a low-quality software product.

    Solution #5: Create “The Entering Testing Page”

    By creating such a page, your testing phase will be seamless and smooth. This will help to lay out the existing problem and bugs more clearly. You can also use online tools for app beta-testing.

    Beta Test Your App With:

     

    Key Takeaways

    Outsourcing a development company can save you a pretty penny that you can invest in the growth of your core business. Offshore development companies usually dedicate a particular team for each app type - iOS developers, Android coders, etc. thus the quality of your future app will be high.

    When outsourcing an app development company, mind the above-mentioned challenges and pitfalls to avoid. Clearly, it’s a good financial and business option since maintaining an in-house app development team costs the Earth. If you know what to expect beforehand, outsourcing an app development company won’t cause any problems.

    Short Bio:

    Tasha Bronitska

    I’m a Blogger at IDAP Group. Writing is my passion, and it’s absolutely true. Nearly all day long I craft must-use how-to guides. When I’m not writing, I’m running. Follow IDAP on Facebook.

    Profile Picture

     

     

     

     

    image2.png

  23. Prequel game Towards The Pantheon: Escaping Eternity is out NOW!
    Download it free from Itch.io and Gamejolt!
    Itch.io: https://connorort.itch.io/towards-the-pantheon-escaping-eternity
    Gamejolt: https://gamejolt.com/games/ttpee/280482
    Due to complications the Steam version will release soon in the coming days. You will be able to find it at:
    http://store.steampowered.com/app/709450/Towards_The_Pantheon_Escaping_Eternity/ 

    http://www.towardsthepantheon.com/wp-content/uploads/2017/10/4.png

    Follow the development of Towards The Pantheon on social media!
    Facebook, Twitter, Tumblr, Soundcloud, Instagram, IndieDB, Twitch, Google+, Imgur, Pinterest

    Follow lead developer Connor O.R.T. Linning on social media!
    Facebook, Twitter, Tumblr, Youtube, Soundcloud, Twitch, Instagram, Bandcamp

  24. Are you aspiring to set your foot on the gaming world with an amazing 3D game? Do you want to build your game with the robust platform of Unity? Well, you already know how much important it is to find a reputed Unity game development company for building your game. If you are going through different bids and trying to find ways to choose the right company, you may feel a little confused about the priority of considerations or about where to start your scrutiny.

    Here we are going to shortlist some of the key considerations to make your job easier for finding the ideal one among the multitude of companies working with Unity game development.

    Hire-Unity-game-development-company.jpeg.6609e5b8bd957d80e155f7598f799a6e.jpeg

    1. Make your priorities straight

    You probably have a clear idea of a 3D game development project, and you are expecting to make a mark with the gaming experience of your still to come game. But that is just the beginning. You need to set our priorities first of all. Do you want to unleash your 3D game on several platforms including mobile, web, and consoles? Have you given a thought to the budget of the game development and post-development marketing? All these considerations should be your priorities.

    2. Watch out for the key traits

    Based on the kind of 3D game you wish to build you already have an idea about the kind if developers and their respective qualities you need for the said project. The Unity game developer of your choice should have enough experience in similar projects, and he should be reliable, passionate, responsible and communicative. He should have hands on experience in working in a highly collaborative development environment. Developers who have experience in being kart of both small and big teams are likely to have the required communication skills.
    One big quality for a game developer that you must look for is the passion for technology and creative excellence. To make sure that your chosen developers possess these qualities check their social media status, read their written blogs and have a look at their portfolios and career graph. They must have a solid programming background and experience in similar game development project will be an added qualification.

    3. Know the market

    While having a game project in mind along with the kind of budget you should be prepared with, you should also have a clear idea about the gaming audience you are going to target with your new game and the detailed market dynamics. Have a complete analysis of the market with a comparison of different market rates, and a clear idea about how you are going to produce value over price. When you know that a great developer talent deserves a quality package, you never lose him. Do you know many east European countries really have a lot of talented game developers? Well, you should be ready with the price for the deserving developer talent.

    4.The cost consideration

    You must not forget that though the Unity game engine is relatively cheaper for a company to start, actual development and promotion of the game may involve a significant amount of cost. Apart from the financial cost, a lot of skills, commitment and dedication make a successful game. It is a time-consuming process, and naturally, the development companies take price in consideration to the development time involved. Just remember one thing. Any great piece of work that would deliver you millions in future cannot come cheap. So, always have a realistic budget in mind keeping the development challenges in mind.

    5. On time delivery

    The creation of a 3D game is just the beginning of a long process involving pre-launch and post-launch marketing, promotions and continuous upgradation. The game market is tremendously competitive, and no game idea is safe from being reproduced. Naturally, making a project successful also depends upon how faster a development process and time to market you can ensure. In this respect, on-time delivery of the finished game is a crucial consideration. Only when the game release date is finalised, the company can turn on to a robust pre-launch campaign to create buzz around the new game. Missing the milestones and deadlines is a sheer unprofessional act which only shows the incompetence of the developers. So, for your upcoming game project make sure it does not happen.

    6. Don’t forget about the portfolio

    If you are going to hire some developers from a Unity game development company, it is quite obvious that you would like to look at their portfolio to peruse their credentials and competence. But while focusing on the budget, development cost and associated negotiations with a development company, many of us just forget to have a deeper look at the developer portfolios.

    Did they have solid programming experience with other projects? Did they have experience in building similar games? Did the developer achieve some professional acclamation or reward for any of his works developed so far? All these considerations are important. Three things developer portfolios should clearly mention such as the platform-specific programming skills and expertise, the years of experience and the projects completed and the work rate.

    It’s a wrap, guys!

    Finally, you cannot always judge a development company simply on the merit of its completed or successful projects. This is particularly true in case of a high revenue and creatively demanding niche like games. Another company can hire game developers after building a hugely successful game. So, looking at individual developer portfolio along with studying the credentials of the development firm is crucial.