scuti/reflex2q3
1
0
Fork 0
Code Issues Pull Requests Actions Packages Releases Wiki Activity

bug fixes to get pocket-infinity converted

Browse Source
This commit is contained in:
suhrke 2017-07-08 07:20:55 -07:00
parent 10b4074e8a
commit 6c297d44ab
4 changed files with 171 additions and 63 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
ReflexToQ3/Makefile
View File

@ -1,6 +1,6 @@
EX=reflex2q3
CC=g++
CFLAGS=-std=c++11 -I"./includes" -I"./includes/Catch/single_include" -I"./includes/cxxopts/include" -I"/usr/include/eigen3"
CFLAGS=-std=c++11 -I"./includes" -I"./includes/Catch/single_include" -I"./includes/cxxopts/include" -I"/usr/include/eigen3" -g
TESTEX=test/test-parser
UNITEX=test/catch
@ -35,5 +35,5 @@ EntityConverter.o: includes/EntityConverter.cpp
$(CC) -c $^ $(CFLAGS)
clean:
rm *.o *.log $(EX) $(TESTEX) $(UNITEX)
rm *.o *.log $(EX) $(TESTEX)

163
ReflexToQ3/includes/EntityConverter.cpp
View File

@ -25,10 +25,14 @@
#include <sstream>
/*-----------------------------------------------------------------------------
* PUBLIC
*-----------------------------------------------------------------------------*/
EntityConverter::EntityConverter(const std::string &entityMapFile) :
OFFSET_PLAYER(32.0), OFFSET_PICKUP(2.0), BRIGHTNESS_ADJUST(50.0),
OUTPUT_PRECISION(10)
@ -73,7 +77,7 @@ EntityConverter::EntityConverter(const std::string &entityMapFile,
}
}
else {
throw std::ios::failure( "Error: EntityConverter failed to open .map file" );
throw std::ios::failure( "Error: EntityConverter failed to open .map file " + reflexMapFile );
}
fin.close();
haveMapInfo_ = true;
@ -149,12 +153,14 @@ EntityConverter::convert(const std::vector<std::string> &lines)
std::string type;
if ( lines.size() < 1 ) {
throw std::runtime_error("error: empty entity cannot be converted");
throw std::runtime_error(
makeErrorMessage( "error: empty entity cannot be converted", lines ));
}
// second token is the type
std::istringstream iss(lines[0]);
if ( ! (iss >> trash >> type)) {
throw std::runtime_error("error: type is required");
throw std::runtime_error(
makeErrorMessage( "error: type is required", lines ));
}
// If worldspawn, first reenable all gamemodes
@ -213,7 +219,8 @@ EntityConverter::convert(const std::vector<std::string> &lines)
}
}
else {
throw std::runtime_error( "error: Map info must be extracted prior to conversion" );
throw std::runtime_error(
makeErrorMessage( "error: Map info must be extracted prior to conversion", lines ));
}
// If unsupported entity, return empty vector
@ -223,9 +230,13 @@ EntityConverter::convert(const std::vector<std::string> &lines)
/*-----------------------------------------------------------------------------
* PROTECTED
*-----------------------------------------------------------------------------*/
std::vector<std::string>
EntityConverter::convertPickup(const std::vector<std::string> &lines) const
{
@ -238,7 +249,8 @@ EntityConverter::convertPickup(const std::vector<std::string> &lines) const
bool havePickupID = false;
if ( lines.size() < 3 ) {
throw std::runtime_error("error: Pickup entity requires at least 3 lines");
throw std::runtime_error(
makeErrorMessage( "error: Pickup entity requires at least 3 lines", lines ));
}
for (int i = 1; i < lines.size(); i++) {
@ -248,7 +260,8 @@ EntityConverter::convertPickup(const std::vector<std::string> &lines) const
// Vector3 position coord0 coord1 coord2
if ( ! (iss >> trash >> trash >>
coords[0] >> coords[1] >> coords[2])) {
throw std::runtime_error("error: Pickup entity requires coordinates");
throw std::runtime_error(
makeErrorMessage( "error: Pickup entity requires coordinates", lines ));
}
havePosition = true;
}
@ -256,7 +269,8 @@ EntityConverter::convertPickup(const std::vector<std::string> &lines) const
std::istringstream iss(lines[i]);
// UInt8 pickupType ID
if ( ! (iss >> trash >> trash >> pickupID) ) {
throw std::runtime_error("error: Pickup entity requires Pickup ID");
throw std::runtime_error(
makeErrorMessage( "error: Pickup entity requires Pickup ID", lines ));
}
havePickupID = true;
}
@ -265,7 +279,8 @@ EntityConverter::convertPickup(const std::vector<std::string> &lines) const
if ( havePosition && havePickupID ) {
auto pickupIter = pickupMap_.find(pickupID);
if ( pickupIter == pickupMap_.end() ) {
throw std::runtime_error("error: Pickup ID must be valid");
throw std::runtime_error(
makeErrorMessage( "error: Pickup ID must be valid", lines ));
}
std::stringstream pickupStream;
pickupStream << "\"classname\" \"" << pickupIter->second << "\"" << std::endl;
@ -278,7 +293,8 @@ EntityConverter::convertPickup(const std::vector<std::string> &lines) const
return convertedLines;
}
else {
throw std::runtime_error("error: Pickup requires position and pickup ID, missing 1 or both");
throw std::runtime_error(
makeErrorMessage( "error: Pickup requires position and pickup ID, missing 1 or both", lines ));
}
}
@ -314,7 +330,8 @@ EntityConverter::convertPlayerSpawn(const std::vector<std::string> &lines) const
if ( lines.size() < 2 ) {
throw std::runtime_error("error: PlayerSpawn entity requires at least 2 lines");
throw std::runtime_error(
makeErrorMessage( "error: PlayerSpawn entity requires at least 2 lines", lines ));
}
for (int i = 1; i < lines.size(); i++) {
@ -324,7 +341,8 @@ EntityConverter::convertPlayerSpawn(const std::vector<std::string> &lines) const
// Vector3 position coord0 coord1 coord2
if ( ! (iss >> trash >> trash >>
coords[0] >> coords[1] >> coords[2])) {
throw std::runtime_error("error: PlayerSpawn entity requires position coordinates");
throw std::runtime_error(
makeErrorMessage( "error: PlayerSpawn entity requires position coordinates", lines ));
}
havePosition = true;
}
@ -332,7 +350,8 @@ EntityConverter::convertPlayerSpawn(const std::vector<std::string> &lines) const
std::istringstream iss(lines[i]);
// UInt8 pickupType ID
if ( ! (iss >> trash >> trash >> angle )) {
throw std::runtime_error("error: Pickup entity requires Pickup ID");
throw std::runtime_error(
makeErrorMessage( "error: Pickup entity requires Pickup ID", lines ));
}
}
// Bool8 modeX 0 indicates this spawn is not for game mode X
@ -392,7 +411,8 @@ EntityConverter::convertPlayerSpawn(const std::vector<std::string> &lines) const
return convertedLines;
}
else {
throw std::runtime_error("error: PlayerSpawn entity requires position coordinates");
throw std::runtime_error(
makeErrorMessage( "error: PlayerSpawn entity requires position coordinates", lines ));
}
}
@ -406,12 +426,14 @@ EntityConverter::convertJumpPad(const std::vector<std::string> &lines) const
std::string trash;
if ( lines.size() < 2 ) {
throw std::runtime_error("error: JumpPad entity requires at least 2 lines");
throw std::runtime_error(
makeErrorMessage( "error: JumpPad entity requires at least 2 lines", lines ));
}
std::istringstream iss(lines[1]);
// String32 target targetName
if ( ! (iss >> trash >> trash >> targetName) ) {
throw std::runtime_error("error: JumpPad entity requires target name");
throw std::runtime_error(
makeErrorMessage( "error: JumpPad entity requires target name", lines ));
}
convertedLines.push_back ( "\"classname\" \"trigger_push\"\n" );
@ -431,12 +453,14 @@ EntityConverter::convertTeleporter(const std::vector<std::string> &lines) const
std::string trash;
if ( lines.size() < 2 ) {
throw std::runtime_error("error: Teleport entity requires at least 2 lines");
throw std::runtime_error(
makeErrorMessage( "error: Teleport entity requires at least 2 lines", lines ));
}
std::istringstream iss(lines[1]);
// String32 target targetName
if ( ! (iss >> trash >> trash >> targetName) ) {
throw std::runtime_error( "error: Teleport entity requires target name" );
throw std::runtime_error(
makeErrorMessage( "error: Teleport entity requires target name", lines ));
}
convertedLines.push_back ( "\"classname\" \"trigger_teleport\"\n" );
@ -463,7 +487,8 @@ EntityConverter::convertTarget(const std::vector<std::string> &lines) const
if ( lines.size() < 3 ) {
throw std::runtime_error("error: Target entity requires at least 3 lines");
throw std::runtime_error(
makeErrorMessage( "error: Target entity requires at least 3 lines", lines ));
}
for (int i = 1; i < lines.size(); i++) {
@ -473,7 +498,8 @@ EntityConverter::convertTarget(const std::vector<std::string> &lines) const
// Vector3 position coord0 coord1 coord2
if ( ! (iss >> trash >> trash >>
coords[0] >> coords[1] >> coords[2])) {
throw std::runtime_error( "error: Target entity requires coordinates" );
throw std::runtime_error(
makeErrorMessage( "error: Target entity requires coordinates", lines ));
}
havePosition = true;
}
@ -481,7 +507,8 @@ EntityConverter::convertTarget(const std::vector<std::string> &lines) const
std::istringstream iss(lines[i]);
// UInt8 name uniqueName
if ( ! (iss >> trash >> trash >> targetName) ) {
throw std::runtime_error( "error: Target entity requires target name" );
throw std::runtime_error(
makeErrorMessage( "error: Target entity requires target name", lines ));
}
haveName = true;
}
@ -489,7 +516,8 @@ EntityConverter::convertTarget(const std::vector<std::string> &lines) const
std::istringstream iss(lines[i]);
// Vector3 angles angle notapplicable notapplicable
if ( ! (iss >> trash >> trash >> angle) ) {
throw std::runtime_error( "error: Target entity requires target angle if specified" );
throw std::runtime_error(
makeErrorMessage( "error: Target entity requires target angle if specified", lines ));
}
haveAngle = true;
}
@ -499,14 +527,8 @@ EntityConverter::convertTarget(const std::vector<std::string> &lines) const
if ( havePosition && haveName) {
auto targetIter = targetMap_.find(targetName);
if ( targetIter == targetMap_.end() ) {
std::cerr << "EntityConverter doesn't know what the source of a Target entity with the "
<< "following attributes. It is probably an unsupported entity type or feature. "
<< "(game over camera, etc). Returning an empty vector." << std::endl;
std::vector<std::string>::const_iterator it;
for ( it=lines.begin(); it!=lines.end(); ++it ) {
std::cerr << *it << std::endl;
}
std::cerr << std::endl;
std::cerr << makeErrorMessage("EntityConverter doesn't know what the source of a Target entity with the following attributes. This entity will not be converted. It is probably an unsupported entity type or feature. (e.g. game over camera)", lines);
std::vector<std::string> empty;
return empty;
}
@ -540,7 +562,8 @@ EntityConverter::convertTarget(const std::vector<std::string> &lines) const
return convertedLines;
}
else {
throw std::runtime_error("error: Target entity requires position coordinates and targetname");
throw std::runtime_error(
makeErrorMessage( "error: Target entity requires position coordinates and targetname", lines ));
}
}
@ -577,17 +600,19 @@ EntityConverter::convertPointLight(const std::vector<std::string> &lines) const
std::vector<std::string> convertedLines;
//position and intensity required, color optional
std::string coords[3];
std::string intensity;
//default to a typical value
std::string intensity = "1.0";
//color is hex 8 digits
std::string color;
//default to white if no color specified
std::string color = "ff000000";
std::string trash;
bool havePosition = false;
bool haveIntensity = false;
bool haveColor = false;
if ( lines.size() < 3 ) {
throw std::runtime_error("error: PointLight entity requires at least 3 lines");
if ( lines.size() < 2 ) {
throw std::runtime_error(
makeErrorMessage( "error: PointLight entity requires at least 2 lines", lines ));
}
for (int i = 1; i < lines.size(); i++) {
@ -597,7 +622,8 @@ EntityConverter::convertPointLight(const std::vector<std::string> &lines) const
// Vector3 position coord0 coord1 coord2
if ( ! (iss >> trash >> trash >>
coords[0] >> coords[1] >> coords[2])) {
throw std::runtime_error( "error: PointLight entity requires position coordinates" );
throw std::runtime_error(
makeErrorMessage( "error: PointLight entity requires valid position coordinates", lines ));
}
havePosition = true;
}
@ -605,15 +631,16 @@ EntityConverter::convertPointLight(const std::vector<std::string> &lines) const
std::istringstream iss(lines[i]);
// Float intensity validFloat
if ( ! (iss >> trash >> trash >> intensity) ) {
throw std::runtime_error( "error: PointLight entity requires intensity value" );
throw std::runtime_error(
makeErrorMessage( "error: PointLight intensity keyword must be followed by a value", lines ));
}
haveIntensity = true;
}
else if ( type == "color" ) {
std::istringstream iss(lines[i]);
// ColourXRGB32 color eightDigitHexValue
if ( ! (iss >> trash >> trash >> color) ) {
throw std::runtime_error( "error: PointLight entity requires valid float value if specified" );
throw std::runtime_error(
makeErrorMessage( "error: PointLight color keyword must be followed by a value", lines ));
}
haveColor = true;
}
@ -621,7 +648,7 @@ EntityConverter::convertPointLight(const std::vector<std::string> &lines) const
}
if ( havePosition && haveIntensity) {
if ( havePosition ) {
convertedLines.push_back ( "\"classname\" \"light\"\n" );
// coordinates reordered to x, z, y
std::stringstream positionStream;
@ -633,27 +660,30 @@ EntityConverter::convertPointLight(const std::vector<std::string> &lines) const
intensityStream << "\"light\" \"" << adjustBrightness(intensity) << "\"\n";
convertedLines.push_back ( intensityStream.str() );
float red;
float green;
float blue;
if ( haveColor ) {
std::stringstream colorStream;
float red;
float green;
float blue;
// Convert 32bit hex RGBA value (ALPHA ALWAYS FULL) into RGB values
hexToRGB(color, red, green, blue);
colorStream << "\"_color\" \"" << red << " " << green << " " << blue << "\"" << std::endl;
convertedLines.push_back (colorStream.str() );
}
std::stringstream colorStream;
colorStream << "\"_color\" \"" << red << " " << green << " " << blue << "\"" << std::endl;
convertedLines.push_back (colorStream.str() );
return convertedLines;
}
else {
throw std::runtime_error("error: Target entity requires position coordinates and targetname");
throw std::runtime_error(
makeErrorMessage( "error: PointLight entity requires position coordinates", lines ));
}
}
/*-----------------------------------------------------------------------------
* PRIVATE
*-----------------------------------------------------------------------------*/
std::string
EntityConverter::getAttributeType(const std::string &line) const
{
@ -684,7 +714,7 @@ EntityConverter::mapEntities(const std::string &mapFile)
int id;
std::string pickup;
if ( ! (iss >> id >> pickup)) {
throw std::runtime_error( "format error in .ent file" );
throw std::runtime_error( "format error in Pickup .pck file " + mapFile );
}
pickupMap_.insert ( std::pair<int, std::string>(id, pickup) );
}
@ -708,7 +738,7 @@ EntityConverter::extractFromEntity(const std::string &line, std::istream &is)
std::getline(is, nextLine);
std::istringstream iss(nextLine);
if ( ! (iss >> trash >> trash >> targetName)) {
throw std::runtime_error( "format error in .map file");
throw std::runtime_error( "Format error in .map file" );
}
targetMap_.insert ( std::pair<std::string, std::string>(targetName, "Teleporter") );
}
@ -716,7 +746,7 @@ EntityConverter::extractFromEntity(const std::string &line, std::istream &is)
std::getline(is, nextLine);
std::istringstream iss(nextLine);
if ( ! (iss >> trash >> trash >> targetName)) {
throw std::runtime_error( "format error in .map file");
throw std::runtime_error( "Format error in .map file" );
}
targetMap_.insert ( std::pair<std::string, std::string>(targetName, "JumpPad") );
}
@ -784,6 +814,33 @@ EntityConverter::adjustBrightness(const std::string &value) const
std::string
EntityConverter::makeErrorMessage(const std::string message,
const std::vector<std::string> entity) const
{
std::stringstream ss;
ss << std::endl << message << std::endl;
std::vector<std::string>::const_iterator it;
for ( it=entity.begin(); it!=entity.end(); ++it ) {
ss << *it << std::endl;
}
ss << std::endl;
return ss.str();
}
/*-----------------------------------------------------------------------------
* PRIVATE
*-----------------------------------------------------------------------------*/
// DEBUG
void
EntityConverter::printMapping() const

9
ReflexToQ3/includes/EntityConverter.hpp
View File

@ -206,6 +206,15 @@ class EntityConverter
*--------------------------------------------------------------------------------------
*/
int adjustBrightness(const std::string &value) const;
/*
*--------------------------------------------------------------------------------------
* Class: EntityConverter
* Method: EntityConverter :: makeErrorMessage
* Description: Combine a message and the entity responsible into an error message
*--------------------------------------------------------------------------------------
*/
std::string makeErrorMessage(const std::string message,
const std::vector<std::string> entity) const;

54
ReflexToQ3/test/catch.cpp
View File

@ -431,6 +431,50 @@ TEST_CASE( "r2x: a single PointLight entity can be converted", "[EntityConverter
REQUIRE( converted[1] == "\"origin\" \"-216.00000 -1488.000488 -132.00000\"\n" );
REQUIRE( converted[2] == "\"light\" \"75\"\n" );
INFO( converted[3] );
std::istringstream iss(converted[3]);
std::string attribute;
std::string r;
float red;
float green;
float blue;
iss >> attribute >> r >> green >> blue;
r.erase(r.begin()); //removing preceding quote is necessary
std::stringstream redStream(r);
redStream >> red;
REQUIRE( attribute == "\"_color\"" );
REQUIRE( fabs( 1.0 - red) <= DELTA );
REQUIRE( fabs( 0.768627 - green) <= DELTA );
REQUIRE( fabs( 0.0 - blue) <= DELTA );
}
TEST_CASE( "r2x: PointLight defaults to white light of typical intensity", "[EntityConverter]" ) {
// Instantiate object
EntityConverter ec (PICKUP_FILENAME);
// Mock up entity
std::vector<std::string> entity;
entity.push_back(" type PointLight");
entity.push_back(" Vector3 position -216.00000 -132.00000 -1488.000488");
// Mock up entity queue
std::queue<std::vector<std::string>> q;
q.push( entity );
// Match related entities (none)
ec.extractMapInfo( q );
// Convert a single entity
std::vector<std::string> converted = ec.convert(entity);
REQUIRE( converted[0] == "\"classname\" \"light\"\n" );
REQUIRE( converted[1] == "\"origin\" \"-216.00000 -1488.000488 -132.00000\"\n" );
REQUIRE( converted[2] == "\"light\" \"50\"\n" );
INFO( converted[3] );
std::istringstream iss(converted[3]);
std::string attribute;
@ -445,9 +489,10 @@ TEST_CASE( "r2x: a single PointLight entity can be converted", "[EntityConverter
REQUIRE( attribute == "\"_color\"" );
REQUIRE( fabs(1.0 - red) <= DELTA );
REQUIRE( fabs(0.768627 - green) <= DELTA );
REQUIRE( fabs(0.0 - blue) <= DELTA );
REQUIRE( fabs( 0.0 - red) <= DELTA );
REQUIRE( fabs( 0.0 - green) <= DELTA );
REQUIRE( fabs( 0.0 - blue) <= DELTA );
}
@ -457,8 +502,5 @@ TEST_CASE( "r2x: a single PointLight entity can be converted", "[EntityConverter
#endif //CATCH_CONFIG_MAIN