You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
 
 
 
 
 
 
stk-derbymod/tools/create_kart_properties.py

284 lines
11 KiB

#!/usr/bin/env python3
#
# SuperTuxKart - a fun racing game with go-kart
# Copyright (C) 2006-2015 SuperTuxKart-Team
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 3
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
# This script creates code for the characteristics.
# It takes an argument that specifies what the output of the script should be.
# The output options can be seen by running this script without arguments.
# A more convenient version to update the code is to run update_characteristics.py
import sys
# Input data
# Each line contains a topic and the attributes of that topic.
# This model is used for the xml file and to access the kart properties in the code.
characteristics = """Suspension: stiffness, rest, travel, expSpringResponse(bool), maxForce
Stability: rollInfluence, chassisLinearDamping, chassisAngularDamping, downwardImpulseFactor, trackConnectionAccel, angularFactor(std::vector<float>/floatVector), smoothFlyingImpulse
Turn: radius(InterpolationArray), timeResetSteer, timeFullSteer(InterpolationArray)
Engine: power, maxSpeed, genericMaxSpeed, brakeFactor, brakeTimeIncrease, maxSpeedReverseRatio
Gear: switchRatio(std::vector<float>/floatVector), powerIncrease(std::vector<float>/floatVector)
Mass
Wheels: dampingRelaxation, dampingCompression
Jump: animationTime
Lean: max, speed
Anvil: duration, weight, speedFactor
Parachute: friction, duration, durationOther, durationRankMult, durationSpeedMult, lboundFraction, uboundFraction, maxSpeed
Friction: kartFriction
Bubblegum: duration, speedFraction, torque, fadeInTime, shieldDuration
Zipper: duration, force, speedGain, maxSpeedIncrease, fadeOutTime
Swatter: duration, distance, squashDuration, squashSlowdown
Plunger: bandMaxLength, bandForce, bandDuration, bandSpeedIncrease, bandFadeOutTime, inFaceTime
Startup: time(std::vector<float>/floatVector), boost(std::vector<float>/floatVector)
Rescue: duration, vertOffset, height
Explosion: duration, radius, invulnerabilityTime
Nitro: duration, engineForce, engineMult, consumption, smallContainer, bigContainer, maxSpeedIncrease, fadeOutTime, max
Slipstream: durationFactor, baseSpeed, length, width, innerFactor, minCollectTime, maxCollectTime, addPower, minSpeed, maxSpeedIncrease, fadeOutTime
Skid: increase, decrease, max, timeTillMax, visual, visualTime, revertVisualTime, minSpeed, timeTillBonus(std::vector<float>/floatVector), bonusSpeed(std::vector<float>/floatVector), bonusTime(std::vector<float>/floatVector), bonusForce(std::vector<float>/floatVector), physicalJumpTime, graphicalJumpTime, postSkidRotateFactor, reduceTurnMin, reduceTurnMax, enabled(bool)"""
""" A GroupMember is an attribute of a group.
In the xml files, a value will be assigned to it.
If the name of the attribute is 'value', the getter method will only
contain the group name and 'value' will be omitted (e.g. used for mass). """
class GroupMember:
def __init__(self, name, typeC, typeStr):
self.name = name
if name == "value":
self.getName = ""
else:
self.getName = name
self.typeC = typeC
self.typeStr = typeStr
""" E.g. power(std::vector<float>/floatVector)
or speed(InterpolationArray)
The default type is float
The name 'value' is special: Only the group name will be used to access
the member but in the xml file it will be still value (because we
need a name). """
def parse(content):
typeC = "float"
typeStr = typeC
name = content.strip()
pos = content.find("(")
end = content.find(")", pos)
if pos != -1 and end != -1:
name = content[:pos].strip()
pos2 = content.find("/", pos, end)
if pos2 != -1:
typeC = content[pos + 1:pos2].strip()
typeStr = content[pos2 + 1:end].strip()
else:
typeC = content[pos + 1:end].strip()
typeStr = typeC
return GroupMember(name, typeC, typeStr)
""" A Group has a base name and can contain GroupMembers.
In the xml files, a group is a tag. """
class Group:
def __init__(self, baseName):
self.baseName = baseName
self.members = []
""" Parses and adds a member to this group """
def addMember(self, content):
self.members.append(GroupMember.parse(content))
def getBaseName(self):
return self.baseName
""" E.g. engine: power, gears(std::vector<Gear>/Gears)
or mass(float) or only mass """
def parse(content):
pos = content.find(":")
if pos == -1:
group = Group(content)
group.addMember("value")
return group
else:
group = Group(content[:pos].strip())
for m in content[pos + 1:].split(","):
group.addMember(m)
return group
""" Creates a list of words from a titlecase string """
def toList(name):
result = []
cur = ""
for c in name:
if c.isupper() and len(cur) != 0:
result.append(cur)
cur = ""
cur += c.lower()
if len(cur) != 0:
result.append(cur)
return result
""" titleCase: true = result is titlecase
false = result has underscores """
def joinSubName(group, member, titleCase):
words = toList(group.baseName) + toList(member.getName)
first = True
if titleCase:
words = [w.title() for w in words]
return "".join(words)
else:
return "_".join(words)
# Functions to generate code
def createEnum(groups):
for g in groups:
print()
print(" // {0}".format(g.getBaseName().title()))
for m in g.members:
print(" {0},".format(joinSubName(g, m, False).upper()))
def createAcDefs(groups):
for g in groups:
print()
for m in g.members:
nameTitle = joinSubName(g, m, True)
nameUnderscore = joinSubName(g, m, False)
typeC = m.typeC
print(" {0} get{1}() const;".
format(typeC, nameTitle, nameUnderscore))
def createAcGetter(groups):
for g in groups:
for m in g.members:
nameTitle = joinSubName(g, m, True)
nameUnderscore = joinSubName(g, m, False)
typeC = m.typeC
result = "result"
print("""// ----------------------------------------------------------------------------
{3} AbstractCharacteristic::get{1}() const
{{
{0} result;
bool is_set = false;
process({2}, &result, &is_set);
if (!is_set)
Log::fatal("AbstractCharacteristic", "Can't get characteristic %s",
getName({2}).c_str());
return {4};
}} // get{1}
""".format(m.typeC, nameTitle, nameUnderscore.upper(), typeC, result))
def createKpDefs(groups):
for g in groups:
print()
for m in g.members:
nameTitle = joinSubName(g, m, True)
nameUnderscore = joinSubName(g, m, False)
typeC = m.typeC
print(" {0} get{1}() const;".
format(typeC, nameTitle, nameUnderscore))
def createKpGetter(groups):
for g in groups:
for m in g.members:
nameTitle = joinSubName(g, m, True)
nameUnderscore = joinSubName(g, m, False)
typeC = m.typeC
result = "result"
print("""// ----------------------------------------------------------------------------
{1} KartProperties::get{0}() const
{{
return m_cached_characteristic->get{0}();
}} // get{0}
""".format(nameTitle, typeC))
def createGetType(groups):
for g in groups:
for m in g.members:
nameTitle = joinSubName(g, m, True)
nameUnderscore = joinSubName(g, m, False)
print(" case {0}:\n return TYPE_{1};".
format(nameUnderscore.upper(), "_".join(toList(m.typeStr)).upper()))
def createGetName(groups):
for g in groups:
for m in g.members:
nameTitle = joinSubName(g, m, True)
nameUnderscore = joinSubName(g, m, False).upper()
print(" case {0}:\n return \"{0}\";".
format(nameUnderscore))
def createLoadXml(groups):
for g in groups:
print(" if (const XMLNode *sub_node = node->getNode(\"{0}\"))\n {{".
format(g.baseName.lower()))
for m in g.members:
nameUnderscore = joinSubName(g, m, False)
nameMinus = "-".join(toList(m.name))
print(""" sub_node->get(\"{0}\",
&m_values[{1}]);""".
format(nameMinus, nameUnderscore.upper()))
print(" }\n")
# Dicionary that maps an argument string to a tupel of
# a generator function, a help string and a filename
functions = {
"enum": (createEnum, "List the enum values for all characteristics", "karts/abstract_characteristic.hpp"),
"acdefs": (createAcDefs, "Create the header function definitions", "karts/abstract_characteristic.hpp"),
"acgetter": (createAcGetter, "Implement the getters", "karts/abstract_characteristic.cpp"),
"getType": (createGetType, "Implement the getType function", "karts/abstract_characteristic.cpp"),
"getName": (createGetName, "Implement the getName function", "karts/abstract_characteristic.cpp"),
"kpdefs": (createKpDefs, "Create the header function definitions for the getters", "karts/kart_properties.hpp"),
"kpgetter": (createKpGetter, "Implement the getters", "karts/kart_properties.cpp"),
"loadXml": (createLoadXml, "Code to load the characteristics from an xml file", "karts/xml_characteristic.cpp"),
}
def main():
# Find out what to do
if len(sys.argv) != 2:
print("""Usage: ./create_kart_properties.py <operation>
Operations:""")
maxOperationLength = 0
maxDescriptionLength = 0
for o, f in functions.items():
l = len(o)
if l > maxOperationLength:
maxOperationLength = l
l = len(f[1])
if l > maxDescriptionLength:
maxDescriptionLength = l
formatString = " {{0:{0}}} {{1:{1}}} in {{2}}".format(maxOperationLength, maxDescriptionLength)
for o, f in functions.items():
print(formatString.format(o, f[1], f[2]))
return
task = sys.argv[1]
if task not in functions:
print("The wanted operation was not found. Please call this script without arguments to list available arguments.")
return
# Parse properties
groups = [Group.parse(line) for line in characteristics.split("\n")]
# Create the wanted code
functions[task][0](groups)
if __name__ == '__main__':
main()