[Vinesauce] Vinny - The Fantastic Game

Click here and disable ads!

Someone on youtube reviewed it, that someone is Vinesauce.



Description:
The game uses Unity3D. I recognize the spare folder name ending in data. oh and the player of course!
The game is about collecting dollars and I guess solving puzzles?



I have some criticisms of this game. I have tested this game personally.

-Input sensitivity issues. Sometime it is too extreme and yet sometimes seems to stick when trying to turn the view and walk.

-The level layout needs to be more unified.
-Add some signs, rails in long bridges.
-The texture quality is a strength in this game (atleast when it wants to be), but more trash/clutter should be stamped on the ground/walls.
-Decorate things that link to new areas better.
-Hard to climb the stones outside that building that contains the orbs.
-The giant eggs are too white. Paint something on them.
-If you try to walk your way to the "nice underpants area" you can hit something that lets you drop forever. if that is attention at least notify the user they are fucked.
-IN the beginning those trailstones that make instruments sounds should become warp pads or when tapped in an order give a dollar.

One strength of this game is the Gkey respawn. That is a clever method to prevent a user from having to walk back to the start area.

Is it your game, Prosper?

No but I am in transition of making a decent RPG combat. The code is very much incomplete but this skeleton says more than enough.
Don't steal

Code:

#include <iostream>
#include <string>

#include <stdio.h>
#include <stdlib.h>
#include <cstdlib> // for rand() and srand()
#include <ctime> // for time()

using namespace std;



float fErrorAllowed = 5.0f;
float fAccuracyNeeded = 95.0f;

unsigned int GetRandomNumber(int nLow, int nHigh);

// Effects will need containers.. STL usage for BOOST FUN.

class Effect
{
public:
    std::string name;
    float fOnHitActivateChance;
    float fOnMissActivateChance;
    float fOnEvadedActivateChance;
};

class CAttack
{
public:
    std::string name;
    Effect* effects;

};

class Stats
{
public:
    void Damage(std::string statname, float amount);
    void CauseEffect(Effect eff);
    void DeductFromSkillUse(std::string attackname);
};

class Entity
{
public:
    Entity();
    Stats stats;
    CAttack DecideOnAttack();
    void Attack(Entity& target);
    bool Evaded;
    bool isPlayer;
    CAttack currentAttack;
};

float toHit(Entity& attacker, Entity& defender);
float toHurt(Entity& attacker, Entity& defender);
bool HasHit(float fVal, float fValMax);

int main()
{
    srand(time(0));
    cout << "Time set" << endl;
    cout << "Loop starting." << endl;

    while(1)
    {
        cout << "Choose from 0.0 to 100.0" << endl;
        float fVal;
        cin >> fVal;

        bool bHasHit = HasHit(fVal, 100.0);
        cout << "Result: " << bHasHit << endl;



        // Check if user wants to quit.
        std::string strInput;
        getline(cin, strInput);
        if (strInput == "q")
        {
            break;
        }
    }


    cout << "End program." << endl;

    return 0;
}

unsigned int GetRandomNumber(int nLow, int nHigh)
{
    return (rand() % (nHigh - nLow + 1)) + nLow;
}

bool HasHit(float fVal, float fValMax)
{
    bool bHasHit = false;

    if (fVal < 0.0)
    {
        return bHasHit;
    }

    unsigned int nResult = GetRandomNumber((unsigned int)fVal, (unsigned int)fValMax);

    if ((nResult + fErrorAllowed) >= 100.0)
    {
        bHasHit = true;
    }

    return bHasHit;
}


void Stats::Damage(std::string statname, float amount)
{


}

void Stats::CauseEffect(Effect eff)
{

}

class Penalty
{
public:
    void Execute(bool Evaded, Entity& attacker, Entity& defender);
    int whoGetsEffected; // 0 = attacker // 1 = defender // 2 = both
    Effect* effects;

};

Entity::Entity()
{

}
void Entity::Attack(Entity& target)
{
    CAttack attackChosen;

    if (isPlayer == true)
    {
        attackChosen = currentAttack;
    }
    else
    {
        attackChosen = DecideOnAttack();
    }

    stats.DeductFromSkillUse(attackChosen.name);

    float fToHit = toHit(*this, target);
    float fMinimumAllowed = fToHit + fErrorAllowed;
    if (fMinimumAllowed >= fAccuracyNeeded)
    {

        float fToHurt = toHurt(*this, target);
        target.stats.Damage("Health", fToHurt);

        /*
        * todo use boost for each
        foreach(Effect eff in attackChosen.effects)
        {
            target.stats.CauseEffect(eff);
        }
        */
    }
    else
    {
        /* todo use boost for each
        foreach(Penalty pen in attackChosen.penalties) {
                    pen.Execute(target.Evaded, *this, target);
        }
        */
    }

}

void Stats::DeductFromSkillUse(std::string attackname)
{
    // update stats for having used the attack.
}

float toHit(Entity& attacker, Entity& defender)
{
    float fVal = 0.0f;
    return fVal;

}

float toHurt(Entity& attacker, Entity& defender)
{
    float fVal = 0.0f;
    return fVal;

}

CAttack Entity::DecideOnAttack()
{
    CAttack derpAttack;
    return derpAttack;
}

void Penalty::Execute(bool Evaded, Entity& attacker, Entity& defender)
{
    // code:
    // what happens to attacker on attacker miss?
    // what happens to attacker on defender evade?
    // what happens to defender on attacker miss?
    // what happens to defender on defender evade? (attacker's special..)
}

Holy shit. That game is full of win.

Diablo 3 finally broke you ?

Holy shit incline of Konjad.