metaprogramming with variadic templates in C++

A simple solution is to add another explicit parameter to the second overload:

template <typename T, typename T2, typename... Args> void printtypes()
{
    std::cout << typeName<T>() << std::endl;
    printtypes<T2,Args...>();
}

While this answer does not answer your specific question about variadic templates, I hope it does answer your underlying question about how to make your game engine extensible.

What you came up with by creating your fileParseFunction() is an implementation of the Factory Method pattern. This is the main part that makes it easy to turn stored data into real objects. Unfortunately, it violates the Open-Close Principle making it difficult to reach your end goal, extendability.

For example, in your code above, your factory function can parse "type1", "type2" and "type3" from your data file and generate objects of type1, type2 and type3 but adding more types would mean editing this function and adding a new else if for every new type you wish to add

You've already identified this as a problem and are trying to solve it using variadic templates. Unfortunately, if you extend the number of game objects into the twenties, thirties, or even hundreds of types, variadic templates will become cumbersome to use, if at all they are able to go that far.

A much simpler solution is to use the Abstract Factory pattern. This essentially shifts responsibility for creating game objects from your file parser's Factory Function, to a factory object. Whether this transfer of power goes to a single function, or a fully-fledged class is up to you. You could also templatise this factory to save on coding.

Each of your factories will have to register their existence with the file parser before the parser is called and extending the parser's capabilities will be as simple as creating a new factory and registering it with the parser.

A simple example would be:

class GameObjectAbstractFactory {
public:
    string registeredTypes() const{
        // cycle through hash table to return the names of registered factories
    }

    GameObjectFactory* getFactory(string factoryName){
        // return the registered factory, or nullptr if not registered
    }

    void registerFactory(string factoryName, GameObjectFactory*){
        // add the factory if it doesn't exist
    }

    static GameObjectAbstractFactory* instance(){
        // access to Singleton instance
    }

private:
    GameObjectAbstractFactory(); // enforces Singleton pattern

    Hash<string, GameObjectFactory*> registeredFactories;
};


// Interface class for generating concrete types, can be templatised, depending on implementation
class GameObjectFactory{
public:
    string name() = 0;
    GameObject *createObject() = 0;
};

This would alter your parsing function so that it becomes:

fileParseFunction(string filename)
{
    //code that opens file called "filename" and handles tokenizing/parsing

    GameObjectAbstractFactory *abstractFactory = GameObjectAbstractFactory::instance();

    GameObjectFactory *factory = abstractFactory.getFactory(token);
    if(factory != nullptr)
    {
        gameWorld.add(factory.createObject());
    }

    //other code to finish loading the level 
}

This would then make your fileParseFunction() compliant with the Open-Close Principle in that it could still generate new game objects as your engine is extended but the function itself will not have to be modified in order to do so.

There is a caveat with this pattern though: all the factories need to be registered with the abstract factory before they are needed, otherwise the required game object will not be able to be created.

As I mentioned in the beginning, this answer does not address your direct question about variadic templates but I hope this helps with the extendability of your game engine.