Slower heavies make for a better game

No one researches arty today and we're 100% kewl with that.

 

ok have fun!

 

get the fuck on steam

 

Thought: You shouldn't take a screaming minority as 100% representive of what the active player base wants or what is good for game balance.

 

The Mammoth Tank in C&C Renegade is slow as hell. It serves two things: to make you feel vulnerable to fast-moving units (like the Stealth Tank) and to show that this is a thing that can take a beating. Still, it is a lot of fun to drive and incredibly powerful when coupled with proper back-up.

I'd like to test out those scripts. Could you pass them to Wealthysoup?

 

I guess the question then is, whether the server fills up with mammoth tanks in Renegade, or whether it's one or two with a squad in its shadow, barrelling through the enemy.

The problem with Empires is we can't quite have nice tanks because no tank is niche. We get mediums, everyone gets mediums, we get heavies, everyone gets heavies. Part of the reason people switch from lights to mediums (for NF only) is because the mediums have big gains in weaponry, but they're the special case. For the rest, the step up in power is almost mandatory, and although I myself prefer mediums because they're a little more agile, we have a situation where each tank chassis is TWICE as capable as the previous, rather than 50%. The plating going from 2 to 4 to 8 (though I don't know hull health) is actually not a good idea because it more or less makes the previous chassis redundant.

At least, that's what I'm thinking now. Maybe you guys can have a think about it and tell me if the game would be better with a narrower gradient between tanks, which would keep all chassis somewhat relevant, and also provide the subtle nerfs we've been angling for.

Speed is a good nerf, I won't lie, but I think we'd need two variants of heavy to really provide a proper dynamic - one mammoth that would crawl but be insanely strong (we currently don't actually have a tank that would act like an infantry shield, which is something key missing imo), and one destroyer that would specifically take out enemy tanks. The reason I say we need two variants is because heavies aren't really modelled to be something infantry can move in behind, and it'd be a waste to remove our current heavy tanks.

I know that sounds like "really? you want to give us more vehicles to deal with? and more models to make?" but if you're talking about mammoth tanks and other niches, well we don't really fill them right now.

Also the AFV needs a new model, since it's the one thing that's preventing light tanks from being buffed slightly so they stay relevant. Any buff to the light chassis right now would make LT's once again totally outclass the AFV, as well as be much more fun than the AFV to drive, and if we actually do get the new med model for NF, it'd be unnecessary to have that disproportion.

Sorry for the sprawling "rehaul tanks!" post, but it's basically what I thought and think is the answer to your comment about mammoth tanks, and the way to make tank combat a lot more fun. As well as give games more strategic options. Jeez, yeah it touches everything.

 

I don't mean to suggest that this audience is the only audience that matters.

You probably don't see me in game, but I'm constantly asking players what they would change about Empires. Candles laughed at me just yesterday because of the way that I phrased that exact question to a particular server.

The point is that you make your best attempts to collect data from multiple sources and weight that properly. Unfortunately, proper data collection is difficult so most of these results are subjective, but that's the best we got.

 

Speed mostly only matters during tank vs tank combat.
If all tanks are slow, it won't make tanks much useless.

 

Yeah that's the same, you can keep poking me with your low dps medium tank.

 

Host_Error: SV_CreatePacketEntities: GetEntServerClass failed for ent 1.

just love the weird errors

Anyways.. Spart seems to think the Heavies are still a bit to fast.
I think the point of the conversation was "slow them down... increase armor and dmg a ton."

 

That is my stance, but I don't want that to stop people from experimenting.

If you slowed then to roughly the speed that wet tested tonight and increased the hull hp a bit, then you'd have a mostly balanced tank and people would probably be ok with it.

 

I was talking to Candles in spec the other night about vehicle speed. I learned that speed is the only variable being used to set the engine characteristic of a vehicle. He said there were other variables that could be set but they don't mess with them, since they require alot of research. He also said Spartacus is doing some of that learning right now.

Spartacus - IM me anytime I'm online if you need help with testing.

I think it would be great to have control over engine torque. I'd like to see something in a Coolant class that is slow but with high torque. Enough to push other tanks, but not enough to zip away. Also enough to climb steep hills slowly, where the 3Phase engine would need to make a big circle to get enough momentum to get up the same hill. I think this would change the characteristic of the game and make multiple engine types more useful.

BIODiesel should have high torque but limited speed - right now it has limited speed and useful only due to it being a great nub engine. I like it since I trained on the old style 3Phase and when that changed it fucked up my timing and overheating in tanks.

3Phase should have very low torque, slow start, but higher top end speed. The vets will continue to love this engine for firing when moving and cooling can improve while firing and moving - like it used to. When they get bumped by a coolant tank the coolant tank can push them around. Don't let one of those high torque tanks get near you.

 

It's pretty cool shit, but suspensions are the work of satan.

Code:

// Brenodi Empire Jeep; 

"vehicle"
{
	"body"
	{		
		//"countertorquefactor"	"0.75"
		"massCenterOverride"		"0 0 0"	//-1.5"	//(Left/Right Front/Rear Up/Down) leave at vec3_origin for no override - duke edit - as steve mentioned, this greatly affects wether it rolls or not, and setting it higher (So the center is higher up) tends to lower to tendency to flip
		"massoverride"			"700"		// in kg, leave at 0 for no override (kg)
		"addgravity"			"1"		//0.33"		// keeps car down
		"maxAngularVelocity"		"120"	
		"tiltforce"			"300"	//20
		"tiltforceheight"		"-10"	//64
		"keepuprighttorque"		"1"
	}
	"engine"
	{
		"horsepower"		"250"		// engine power
		"maxrpm"			"1500"	// max rounds per minute
		"maxspeed"			"65"		// forward mph
		"maxReverseSpeed"	"20"		// backward mph
		"autotransmission"	"1"		// true for auto, false for manual
		"axleratio"		"3.56"	// ratio of engine rev to axle rev
		"gear"			"3.5"		// 1st gear (max 6 gears) 
		"gear"			"1.8"		// 2nd gear
		"gear"			"1.26"	// 3rd gear
		"gear"			"1.0"		// 4th gear
		"gear"			"0.84"	// 5th gear
		"shiftuprpm"		"600"		// max RPMs to switch to a higher gear
		"shiftdownrpm"		"250"		// min RPMs to switch to a lower gear
		
		"autobrakeSpeedGain"		"2"		// 10% speed gain while coasting, put on the brakes after that  //VM: can coast down hills faster then with engine
		"autobrakeSpeedFactor"	"3.0"		// Brake is this times the speed gain

// Empires - no boost for you! VM: Fuck you trickster.. BOOST FOR EVERYONE EVERYONE!
		"boost"
		{
			//"force"		"1.5"	// 1.5 car body mass * gravity * inches / second ^ 2
			"duration"		"1.0"	// 1 second of boost
			"delay"		"1.0"	// 15 seconds before you can use it again
			"torqueboost"	"1"	// enable "sprint" mode of vehicle, not	force type booster			
			"maxspeed"		"80"	// maximum turbo speed
			"force"		"5"	// use for value as a boost factor
		}
	}
	
	"steering"
	{
		"degreesSlow"		"40"	// angle in degrees of steering
		"degreesFast"		"20"	// angle in degrees of steering
		"steeringExponent"	"1.0"	// steering function is linear, then raised to this power to be slower at the beginning of the curve, faster at the end

		"slowcarspeed"		"13"	// this is the max speed of "slow"
		"fastcarspeed"		"20"	// this is the min speed of "fast"
		"slowsteeringrate"	"2"	// this is the speed the wheels are steered when the vehicle is "slow"
		"faststeeringrate"	"0.75"	// this is the speed the wheels are steered when the vehicle is "fast"

		"steeringRestRateSlow"		"4.0"	// this is the speed at which the wheels move toward their resting state (straight ahead)
		"steeringRestRateFast"		"4.0"	//2
		"turnThrottleReduceSlow"		"0.25"
		"turnThrottleReduceFast"		"0.25"
		"brakeSteeringRateFactor"		"6"
		"throttleSteeringRestRateFactor"	"2"

		//boost control
		"degreesBoost"				"10"	// steering cone at max boost speed (blend toward this after max speed)
		"boostSteeringRestRateFactor"	"1.7"
		"boostSteeringRateFactor"		"1"

		"skidallowed"		"1"	// true/false skid flag
		"dustcloud"		"1"	// flag for creating a dustcloud behind vehicle

	}
	
	"wheelsperaxle"	"2"	// wheels per axle

	// front axle
	"axle"
	{
		"torquefactor"	"1"
		"brakefactor"	"0.0"	// normalized to 1 across all axles
			
		"wheel"
		{
			"radius"		"18"
			"mass"		"300"		// in kg
			"inertia"		"0.5"		// steady the car (fixes the oscillation of the axles about z)
			"damping"		"0"		//affects fishtailing
			"rotdamping"	"0"		// usually 0
			"material"		"Rubber_Friction_16"	//"jeeptire"	// tire surface properties 
			"skidmaterial"	"Rubber_Friction_2"	//"slidingrubbertire"	// surface properties when sliding
			"brakematerial" "Rubber_Friction_8"	//"brakingrubbertire"	// surface properties wen breaking
		}
		
		"suspension"
		{
			"springConstant"		"100"	//"70"	//Strength of spring, lower values will make spring weaker. Controls how much lean a vehicle will do on turns and how the wheels react when impact from a fall.
			"springDamping"			"1"	//"2"		//0 = almost boblehead spring. This dampens all motion of the springs.
			"stabilizerConstant"		"50"	//"110"	//Fucking stabalizers how do they work?
			"springDampingCompression"	"10"	//"4"		//Higher values effect stearing since the wheels are not contacting ground fast enough after compression in bumpy areas.
			"maxBodyForce"			"600"	//"250"	//How much force can be transferred to the vehicle on impact. Fragile jeeps are fragile!
		}
		"offset"		"0 64 25"	//(Left/Right Front/Rear Up/Down)
		"wheeloffset"	"40 0 0"	//(Left/Right Front/Rear Up/Down)
		
	}

	// rear axle
	"axle"
	{
		"torquefactor"	"0"
		"brakefactor"	"1"
		
		"wheel"
		{
			"radius"		"18"
			"mass"		"300"
			"inertia"		"0.5"		// steady the car (fixes the oscillation of the axles about z)
			"damping"		"0.5"		//affects fishtailing
			"rotdamping"	"0"
			"material"		"Rubber_Friction_16"	//"jeeptire"	// tire surface properties 
			"skidmaterial"	"Rubber_Friction_2"	//"slidingrubbertire"	// surface properties when sliding
			"brakematerial" "Rubber_Friction_8"	//"brakingrubbertire"	// surface properties wen breaking

		}
		"suspension"
		{
			"springConstant"		"100"	//"70"	//Strength of spring, lower values will make spring weaker. Controls how much lean a vehicle will do on turns and how the wheels react when impact from a fall.
			"springDamping"			"1"	//"2"		//0 = almost boblehead spring. This dampens all motion of the springs.
			"stabilizerConstant"		"50"	//"110"	//Fucking stabalizers how do they work?
			"springDampingCompression"	"10"	//"4"		//Higher values effect stearing since the wheels are not contacting ground fast enough after compression in bumpy areas.
			"maxBodyForce"			"600"	//"250"	//How much damage can be transfered to the vehicle on impact. Fragile jeeps are fragile!
		}
		"offset"		"0 -68 25"	//(Left/Right Front/Rear Up/Down)
		"wheeloffset"	"40 0 0"	//(Left/Right Front/Rear Up/Down)
	}
}

Don't forget Viroman.

Can't be done. A particular engine can only replace a handful of the values in the vehicle script.

Candles can't find the variables that need to be overwritten.

 

The following bit makes me think that he isn't talking about engines. Engines are mostly simple (except fuck cooling) and the engine code is 100% accessible by Candles or the other coders.

The engine scripts are tiny and 100% proprietary. Aside from cooling, they are pretty easy to understand.

However, Max Speed, Max Reverse Speed, Shift Up RPM, Shift Down RPM and Horsepower are special. They replace the "default" values in the vehicle script like the one I posted.

Unfortunately, those five are basically the only values that can be replaced because Candles hasn't learned mindreading yet. If a particular engine would allow you to replace all of the values in the vehicle script, then we could so some pretty radical shit.

With the current engines, you can just fuck around with cooling and mess with horsepower. That's certainly powerful, but it's only good for a handful of engines, maybe like 10 max?

If you have an idea and icon art, then make a thread in Suggestions.

 

What I was explaining in that conversation was about the engine scripts directly. Most people give exactly two shits about the engines. The first shit is for max speed and the second is for cooling, and even then, the first shit is much bigger than the second shit.

The problem with fucking with torque/horsepower is that if you make an engine with low torque, it'll quickly lose the ability to go a number of places. Take for example, the slopes on Arid in the north. There's not nearly enough room to ramp up speed to go up the slopes because they're too long and too steep. From a *purely* physics standpoint, a given velocity can only go up a certain height. The more torque you have, the further you can go up, but if your torque can't beat gravity for a given angle, there's only so high it can go. Low torque engines aren't fun, they're frustrating and irritating. If I was playing Empires and my comm gave me a low-torque engine, I'd tell him to fuck off and give me an engine that I can actually do shit with.

There are loads of values we can fuck around with, no problem, but I'm arguing that fucking with them won't give any meaningful benefit to the game, either in terms of diversity or gameplay.

Here's literally every single value from the vehicles.h file relevant to vehicle properties. The extent of documentation of what any of these do is on the same line the value is on. I can throw in the ability to change any of these in the script parsers, but I can't say if they'll even actually do anything.

Code:

struct vehicle_controlparams_t
{
	float	throttle;
	float	steering;
	float	brake;
	float	boost;
	bool	handbrake;
	bool	handbrakeLeft;
	bool	handbrakeRight;
	bool	brakepedal;
	bool	bHasBrakePedal;
	bool	bAnalogSteering;
};

struct vehicle_operatingparams_t
{
	DECLARE_SIMPLE_DATADESC();

	float	speed;
	float	engineRPM;
	int		gear;
	float	boostDelay;
	int		boostTimeLeft;
	float	skidSpeed;
	int		skidMaterial;
	float	steeringAngle;
	int		wheelsNotInContact;
	int		wheelsInContact;
	bool	isTorqueBoosting;
};

// parameters for the body object control of the vehicle
struct vehicle_bodyparams_t
{
	DECLARE_SIMPLE_DATADESC();

	Vector		massCenterOverride;		// leave at vec3_origin for no override
	float		massOverride;			// leave at 0 for no override
	float		addGravity;				// keeps car down
	float		tiltForce;				// keeps car down when not on flat ground
	float		tiltForceHeight;		// where the tilt force pulls relative to center of mass
	float		counterTorqueFactor;
	float		keepUprightTorque;
	float		maxAngularVelocity;		// clamp the car angular velocity separately from other objects to keep stable
};

// wheel objects are created by vphysics, these are the parameters for those objects
// NOTE: They are paired, so only one set of parameters is necessary per axle
struct vehicle_wheelparams_t
{
	DECLARE_SIMPLE_DATADESC();

	float		radius;
	float		mass;
	float		inertia;
	float		damping;		// usually 0
	float		rotdamping;		// usually 0
	float		frictionScale;	// 1.5 front, 1.8 rear
	int			materialIndex;
	int			brakeMaterialIndex;
	int			skidMaterialIndex;
	float		springAdditionalLength;	// 0 means the spring is at it's rest length
};

struct vehicle_suspensionparams_t
{
	DECLARE_SIMPLE_DATADESC();

	float		springConstant;
	float		springDamping;
	float		stabilizerConstant;
	float		springDampingCompression;
	float		maxBodyForce;
};

// NOTE: both raytrace and wheel data here because jetski uses both.
struct vehicle_axleparams_t
{
	DECLARE_SIMPLE_DATADESC();

	Vector						offset;					// center of this axle in vehicle object space
	Vector						wheelOffset;			// offset to wheel (assume other wheel is symmetric at -wheelOffset) from axle center
	Vector						raytraceCenterOffset;	// offset to center of axle for the raytrace data.
	Vector						raytraceOffset;			// offset to raytrace for non-wheel (some wheeled) vehicles
	vehicle_wheelparams_t		wheels;
	vehicle_suspensionparams_t	suspension;
	float						torqueFactor;		// normalized to 1 across all axles 
													// e.g. 0,1 for rear wheel drive - 0.5,0.5 for 4 wheel drive
	float						brakeFactor;		// normalized to 1 across all axles
};

struct vehicle_steeringparams_t
{
	DECLARE_SIMPLE_DATADESC();

	float		degreesSlow;			// angle in degrees of steering at slow speed
	float		degreesFast;			// angle in degrees of steering at fast speed
	float		degreesBoost;			// angle in degrees of steering at fast speed
	float		steeringRateSlow;		// this is the speed the wheels are steered when the vehicle is slow
	float		steeringRateFast;		// this is the speed the wheels are steered when the vehicle is "fast"
	float		steeringRestRateSlow;	// this is the speed at which the wheels move toward their resting state (straight ahead) at slow speed
	float		steeringRestRateFast;	// this is the speed at which the wheels move toward their resting state (straight ahead) at fast speed
	float		speedSlow;				// this is the max speed of "slow"
	float		speedFast;				// this is the min speed of "fast"
	float		turnThrottleReduceSlow;		// this is the amount of throttle reduction to apply at the maximum steering angle
	float		turnThrottleReduceFast;		// this is the amount of throttle reduction to apply at the maximum steering angle
	float		brakeSteeringRateFactor;	// this scales the steering rate when the brake/handbrake is down
	float		throttleSteeringRestRateFactor;	// this scales the steering rest rate when the throttle is down
	float		powerSlideAccel;		// scale of speed to acceleration
	float		boostSteeringRestRateFactor;	// this scales the steering rest rate when boosting
	float		boostSteeringRateFactor;	// this scales the steering rest rate when boosting
	float		steeringExponent;		// this makes the steering response non-linear.  The steering function is linear, then raised to this power

	bool		isSkidAllowed;			// true/false skid flag
	bool		dustCloud;				// flag for creating a dustcloud behind vehicle
};

struct vehicle_engineparams_t
{
	DECLARE_SIMPLE_DATADESC();

	float		horsepower;
	float		maxSpeed;
	float		maxRevSpeed;
	float		maxRPM;					// redline RPM limit
	float		axleRatio;				// ratio of engine rev to axle rev
	float		throttleTime;			// time to reach full throttle in seconds

	// transmission
	int			gearCount;				// gear count - max 10
	float		gearRatio[VEHICLE_MAX_GEAR_COUNT];	// ratio for each gear

	// automatic transmission (simple auto-shifter - switches at fixed RPM limits)
	float		shiftUpRPM;				// max RPMs to switch to a higher gear
	float		shiftDownRPM;			// min RPMs to switch to a lower gear
	float		boostForce;
	float		boostDuration;
	float		boostDelay;
	float		boostMaxSpeed;
	float		autobrakeSpeedGain;
	float		autobrakeSpeedFactor;
	bool		torqueBoost;
	bool		isAutoTransmission;		// true for auto, false for manual
};

struct vehicleparams_t
{
	DECLARE_SIMPLE_DATADESC();

	int							axleCount;
	int							wheelsPerAxle;
	vehicle_bodyparams_t		body;
	vehicle_axleparams_t		axles[VEHICLE_MAX_AXLE_COUNT];
	vehicle_engineparams_t		engine;
	vehicle_steeringparams_t	steering;
};