Rigs of Rods

#include <map>

	void updateTruckPosition();

	// Position Nodes //////////////////////////////////////////////////////////

public:

	typedef unsigned int pos_node_loc;

	//! array helper for nodes types 

	typedef std::vector<pos_node_loc> pos_node_arr;

	//! use a map to ensure there are no duplicate entries 

	typedef std::map<pos_node_loc, pos_node_loc> pos_node_map;

	//! adds a list of nodes to remove from the list

	void addPositionNodes(pos_node_arr nodes);

	void addPositionNode(pos_node_loc node);

	//! removes a list of nodes to remove from the list

	void removePositionNodes(pos_node_arr nodes);

	void removePositionNode(pos_node_loc node);

private:

	//! stores a list of node positions used for calculating a trucks position

	pos_node_map mPositionNodes;

	/**

	 * @param line line in configuration file

	 * @return true if line was successfully parsed, false if not

	 */

	bool parsePositionNodeLine(const Ogre::String& line);

	 * Find node instance based on the id

	/**

	 * Find a group of nodes from a string

	 * @param list of comma separated node values and ranges 

	 * @return a vector of node pointers

	 */

	std::vector<unsigned int> getNodeList(std::string list);

	std::vector<unsigned int> getNodeList(const Ogre::vector<Ogre::String>::type & railStrings);

	 ;

  Beam/BeamPositionNodes.cpp

  Beam/BeamPositionNodes.cpp

		if (!strcmp("position_nodes",line)) {mode=67;continue;};

		else if (mode==67) parsePositionNodeLine(line);

	//

	if( mPositionNodes.empty() )

	{

		addPositionNodes(getNodeList(Ogre::String("0-") + Ogre::StringConverter::toString(free_node)));

	}

void Beam::updateTruckPosition()

{

	for (int n = 0; n < free_node; n++)

	{

		nodes[n].smoothpos = nodes[n].AbsPosition;

	}

	// average position

	Vector3 aposition=Vector3::ZERO;

	// do a seperate loop since there won't be as many nodes

	for( pos_node_map::iterator it = mPositionNodes.begin()

	; it != mPositionNodes.end()

	; it++)

	{

		aposition += nodes[it->second].smoothpos;

	}

	position = aposition / mPositionNodes.size();

}

					trucks[t]->updateTruckPosition();

					trucks[t]->updateTruckPosition();

				updateTruckPosition();

	// ID is usually the same as the array location, check there first

	if( id >= (unsigned int)free_node ) return NULL;

	if( nodes[id].id == (int)id ) return &nodes[id];

std::vector<unsigned int> Beam::getNodeList(std::string list)

{

	return getNodeList(Ogre::StringUtil::split(list, ","));

}

std::vector<unsigned  int> Beam::getNodeList(const Ogre::vector<Ogre::String>::type & nodeStrings)

{

	std::vector<unsigned int> nodeids;

	// convert all strings to integers

	for( unsigned int i = 0; i < nodeStrings.size(); ++i )

	{

		const Ogre::String& node = nodeStrings[i]; 

		// check if value is a node range

		if(node.find("-") == Ogre::String::npos )

		{

			nodeids.push_back(StringConverter::parseInt(node));

			continue;

		}

		size_t pos = node.find("-");

		// from start to '-'

		const int start = StringConverter::parseInt( node.substr(0, pos) );

		// from character after '-' to end 

		const int end = StringConverter::parseInt( node.substr(++pos) );

		for(int j = start ; j <= end; ++j )

		{

			// if end is lower than start then 

			nodeids.push_back( j );

		}

	}

	return nodeids;

}

/**

 @file BeamPositionNodes.cpp

 @author Christopher Ritchey

 @date 07/23/2010

This source file is part of Rigs of Rods

Copyright 2009, 2010 Christopher Ritchey

For more information, see http://www.rigsofrods.com/

Rigs of Rods is free software: you can redistribute it and/or modify

it under the terms of the GNU General Public License version 3, as

published by the Free Software Foundation.

Rigs of Rods 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 Rigs of Rods.  If not, see <http://www.gnu.org/licenses/>.

*/

#include "Beam.h"

bool Beam::parsePositionNodeLine(const Ogre::String& line)

{

	// lines start with exclude or include followed by a node range

	bool add_nodes = Ogre::StringUtil::startsWith(line, "include", true);

	if( !add_nodes && !Ogre::StringUtil::startsWith(line, "exclude", true))

	{

		LogManager::getSingleton().logMessage("PositionNode: lines need to start with Include or Exclude: " + String(line));

		return false;

	}

	size_t start = line.find_first_of("\t ");

	start = line.find_first_not_of("\t ", start);

	pos_node_arr nodelist = getNodeList(line.substr(start));

	if( add_nodes )

		addPositionNodes( nodelist );

	else

		removePositionNodes( nodelist );

	return true;

}

void Beam::addPositionNodes(pos_node_arr nodes)

{

	for(pos_node_arr::iterator it = nodes.begin()

	; it != nodes.end()

	; it++ )

	{

		addPositionNode(*it);

	}

}

void Beam::addPositionNode(pos_node_loc node)

{

	if( node >= free_node ) return; 

	mPositionNodes[node] = node;

}

void Beam::removePositionNodes(pos_node_arr nodes)

{

	for(pos_node_arr::iterator it = nodes.begin()

	; it != nodes.end()

	; it++ )

	{

		removePositionNode(*it);

	}

}

void Beam::removePositionNode(pos_node_loc node)

{

	if( node >= free_node ) return;

	mPositionNodes.erase(node);

}

include_directories(${RoR_SOURCE_DIR}/source/main)

#if wxCHECK_VERSION(2, 9, 0)

#endif