War3:Source

1. I think the best way to achieve what you want is to create a env_smokestack particle (take a look at CreateParticle) set the position and apply the correct velocity to shoot it into the direction you want. If you want to detect collisions you'd have to do the calculations on your own (GetVectorDistance and friends are the way to go because you can't detect collisions with a env_smokestack entity) - it's not 100% accurate but will do the job just fine.

2. There are multiple ways to do this but parenting a prop_dynamic is definitely the best (using TE_SetupGlowSprite and the like that work via the server exclusevily doesn't look as nice as a parented prop_dynamic which is networked from server to client and thus results in a nice smoothness of the effect). You should create the prop_dynamic on spawn to avoid creating and deleting it every time a player crouches/uncrouches. To show/hide it I think you can use the TurnOn/TurnOff Inputs respectively.
Some code to give you an idea:
int g_cardboardEntity[MAXPLAYERSCUSTOM];
onPlayerSpawn(int client)
{
  int ent = CreateEntityByName("prop_dynamic_override");
  DispatchKeyValue(ent, "model", "cardboard.mdl"); //set model (and don't forget to call PrecacheModel with it in OnMapStart)
  SetEntProp(ent, Prop_Data, "m_CollisionGroup", 2);
  SetEntPropEnt(ent, Prop_Send, "m_hOwnerEntity", client);

  DispatchSpawn(ent);

  TeleportEntity(ent, or, ang, NULL_VECTOR);

  SetVariantString("!activator");
  AcceptEntityInput(ent, "SetParent", client, ent, 0);

  SetVariantString("forward"); //not sure if this attachment exists in CS:GO
  AcceptEntityInput(ent, "SetParentAttachmentMaintainOffset", ent, ent, 0);

  g_cardboardEntity[client] = ent;
}

onPlayerCrouch(int client, bool isCrouching)
{
  int ent = g_cardboardEntity[client];
  if(IsValidEntity(ent)) {
    if(isCrouching)
      AcceptEntityInput(ent, "TurnOn");
    else
      AcceptEntityInput(ent, "TurnOff");
  }
}

onPlayerChangesRaceOrDies(int client)
{
  int ent = g_cardboardEntity[client];
  if(IsValidEntity(ent)) {
    AcceptEntityInput(ent, "Kill");
  }
}


Cardboard Box now working exactly as required

Revan, thanks so much mate

I think you're correct, it doesn't look like env_smokestack got a m_vecVelocity netprop that could be used to propel it to a direction on its own.
A simple way to move the entity is to TeleportEntity the env_smokestack a few units every few seconds so it looks like it's moving(this should be pretty easy to do and okay looking)

(...) It looks like there's no pre-defined key value, so would this need to be parented to something else as well?

This is actually a really great idea! You could create a prop (invisible if you want) and PushEntToVector it into the desired direction. The prop (and thus the env_smokestack) will actually bounce of walls because it is a physical entity which would be a quite cool feature - not sure if you want this tho.
To do this just start with the code from the cardboard effect (but don't parent the prop to the player) and attach the smokestack to the prop instead (War3Source_Effects has some cool stuff, like ModifyEntityAttach to make this easier), then you can use PushEntToVector which should do the trick!

Sorry for the late response, better late than never

I tried to disable the gravity and to change the collision groups but no success so far. Disabling gravity might be possible with the VPhysics extension.

I tried to solve the problem differently - It looks pretty cool but you need to tweak the values (speed and duration) to suit your needs:
And you need to use EntReferences in the Timers (because the entity index could be, theoretically, reused and you would kill the wrong entity).
ConVar SpeedVar;
public OnPluginStart()
{
    RegConsoleCmd("fx_smoke",fx_smoke);
    SpeedVar = CreateConVar("fxtest_speed", "12.0");
}

public Action:fx_smoke(client, args)
{
    if(client == 0) {
        PrintToServer("fx_smoke: you need to be in-game");
    } else {
        CreateEnvSmokeStack2(client);
    }

    return Plugin_Handled;
}

CreateEnvSmokeStack2(client)
{
    new SmokeEnt = CreateEntityByName("env_smokestack");
    if(IsValidEdict(SmokeEnt) && IsClientInGame(client))
    {
        new String:originData[64];
        new Float:clientAbsPos[3];    GetClientAbsOrigin(client, clientAbsPos);    clientAbsPos[2]+=40.0;
       
        // SETUP THE SMOKEENT
        Format(originData, sizeof(originData), "%f %f %f", clientAbsPos[0], clientAbsPos[1], clientAbsPos[2]);
        new String:SName[128];
        Format(SName, sizeof(SName), "Smoke%i", client);
        DispatchKeyValue(SmokeEnt,"targetname", SName);
        DispatchKeyValue(SmokeEnt,"Origin", originData);
        DispatchKeyValue(SmokeEnt,"BaseSpread", "50");
        DispatchKeyValue(SmokeEnt,"SpreadSpeed", "50");
        DispatchKeyValue(SmokeEnt,"Speed", "50");
        DispatchKeyValue(SmokeEnt,"StartSize", "50");
        DispatchKeyValue(SmokeEnt,"EndSize", "50");
        DispatchKeyValue(SmokeEnt,"Rate", "30");
        DispatchKeyValue(SmokeEnt,"JetLength", "10");
        DispatchKeyValue(SmokeEnt,"Twist", "10");
        DispatchKeyValue(SmokeEnt,"RenderColor", "255 255 51");
        DispatchKeyValue(SmokeEnt,"RenderAmt", "255");
        DispatchKeyValue(SmokeEnt,"SmokeMaterial", "particle/particle_smokegrenade1.vmt");
       
        // PARENT THE SMOKEENT TO THE HENADE PROJECTILE, SO IT MOVES
        DispatchSpawn(SmokeEnt);
        AcceptEntityInput(SmokeEnt, "TurnOn");

        // get aim pos
        float endpos[3];
        War3_GetAimEndPoint(client, endpos);
       
        DataPack dp;
        CreateDataTimer(0.1, UpdatePos, dp);
        dp.WriteCell(SmokeEnt); //TODO: use ent reference
        dp.WriteFloat(endpos[0]);
        dp.WriteFloat(endpos[1]);
        dp.WriteFloat(endpos[2]);
       
        CreateTimer(8.0,killent,SmokeEnt);
    }
}

public Action UpdatePos(Handle timer, Handle dph)
{
    DataPack dp = view_as<DataPack>(dph);
    dp.Reset();
    int ent = dp.ReadCell();
    if(ent != 0 && IsValidEntity(ent))
    {
        PrintToServer("updatePos %d", ent);
        float x = dp.ReadFloat();
        float y = dp.ReadFloat();
        float z = dp.ReadFloat();
       
        // src and destination vector
        float src[3];
        float dest[3];
        dest[0] = x; dest[1] = y; dest[2] = z;
       
        // Get current entity origin
        GetEntPropVector(ent, Prop_Send, "m_vecOrigin", src);
       
        // do the math
        float direction[3];
        SubtractVectors(dest, src, direction);
        NormalizeVector(direction, direction);
        ScaleVector(direction, SpeedVar.FloatValue);
       
        // update position
        AddVectors(src, direction, src);
        TeleportEntity(ent, src, NULL_VECTOR, NULL_VECTOR);

        // todo: check if player is near enough and damage him
        // <magic></magic>
       
        // re-fire
        DataPack dp2;
        CreateDataTimer(0.1, UpdatePos, dp2);
        dp2.WriteCell(ent); //TODO: use ent reference
        dp2.WriteFloat(x);
        dp2.WriteFloat(y);
        dp2.WriteFloat(z);
    }
    return Plugin_Continue;
}

public Action:killent(Handle:timer, any:Entity)
{
    if(IsValidEdict(Entity))
    {
        AcceptEntityInput(Entity, "Kill");
    }
}