void CPlayGameVorticon::teleportPlayerFromLevel(CPlayer &player, int origx, int origy)
{
int destx, desty;
std::unique_ptr<CTeleporter> teleporter( new CTeleporter(mMap.get(), m_Player, origx, origy) );
player.beingteleported = true;
player.solid = false;
destx = g_pBehaviorEngine->getTeleporterTableAt(5).x;
desty = g_pBehaviorEngine->getTeleporterTableAt(5).y;
teleporter->solid = false;
teleporter->direction = TELEPORTING_SCROLL;
teleporter->destx = destx>>TILE_S;
teleporter->desty = desty>>TILE_S;
teleporter->whichplayer = player.m_index;
mSpriteObjectContainer.push_back(move(teleporter));
}
// setter
int define::update(string& data) {
const char* header = getHeader().c_str();
// get the text
vector<string> lines = BZWParser::getSectionsByHeader(header, data.c_str(), "enddef");
if(lines[0] == BZW_NOT_FOUND)
return 0;
if(lines.size() > 1) {
printf("define::update(): Error! Defined \"define\" %d times!\n", (int)lines.size());
return 0;
}
// get the name
vector<string> names = BZWParser::getValuesByKey("define", header, lines[0].c_str());
if(!hasOnlyOne(names, header))
return 0;
// get the data
string::size_type sectionStart = lines[0].find("\n") + 1;
string::size_type sectionLength = lines[0].find( "enddef", sectionStart ) - sectionStart;
lines[0] = lines[0].substr( sectionStart, sectionLength );
const char* defineData = lines[0].c_str();
// get the chunks
vector<string> chunks = BZWParser::getSections( defineData );
// get all the supported objects from the lines, but don't commit them yet
// arc
vector<string> arcs = BZWParser::findSections("arc", chunks);
vector<arc> arcData;
if(arcs[0] != BZW_NOT_FOUND) {
for(vector<string>::iterator i = arcs.begin(); i != arcs.end(); i++) {
arc tmp = arc();
if(!tmp.update(*i))
return 0;
arcData.push_back( tmp );
}
}
// base
vector<string> bases = BZWParser::findSections("base", chunks);
vector<base> baseData;
if(bases[0] != BZW_NOT_FOUND) {
for(vector<string>::iterator i = bases.begin(); i != bases.end(); i++) {
base tmp = base();
if(!tmp.update(*i))
return 0;
baseData.push_back( tmp );
}
}
// box
vector<string> boxes = BZWParser::findSections("box", chunks);
vector<box> boxData;
if(boxes[0] != BZW_NOT_FOUND) {
for(vector<string>::iterator i = boxes.begin(); i != boxes.end(); i++) {
box tmp = box();
if(!tmp.update(*i))
return 0;
boxData.push_back( tmp );
}
}
// cone
vector<string> cones = BZWParser::findSections("cone", chunks);
vector<cone> coneData;
if(cones[0] != BZW_NOT_FOUND) {
for(vector<string>::iterator i = cones.begin(); i != cones.end(); i++) {
cone tmp = cone();
if(!tmp.update(*i))
return 0;
coneData.push_back( tmp );
}
}
// group
vector<string> groups = BZWParser::findSections("group", chunks);
vector<group> groupData;
if(groups[0] != BZW_NOT_FOUND) {
for(vector<string>::iterator i = groups.begin(); i != groups.end(); i++) {
group tmp = group();
if(!tmp.update(*i))
return 0;
groupData.push_back( tmp );
}
}
// mesh
vector<string> meshes = BZWParser::findSections("mesh", chunks);
vector<mesh> meshData;
if(meshes[0] != BZW_NOT_FOUND) {
for(vector<string>::iterator i = meshes.begin(); i != meshes.end(); i++) {
mesh tmp = mesh();
if(!tmp.update(*i))
return 0;
meshData.push_back( tmp );
}
}
// meshbox
vector<string> meshboxes = BZWParser::findSections("meshbox", chunks);
vector<meshbox> meshboxData;
if(meshboxes[0] != BZW_NOT_FOUND) {
for(vector<string>::iterator i = meshboxes.begin(); i != meshboxes.end(); i++) {
meshbox tmp = meshbox();
if(!tmp.update(*i))
return 0;
meshboxData.push_back( tmp );
}
}
// meshpyr
vector<string> meshpyrs = BZWParser::findSections("meshpyr", chunks);
vector<meshpyr> meshpyrData;
if(meshpyrs[0] != BZW_NOT_FOUND) {
for(vector<string>::iterator i = meshpyrs.begin(); i != meshpyrs.end(); i++) {
meshpyr tmp = meshpyr();
if(!tmp.update(*i))
return 0;
meshpyrData.push_back( tmp );
}
}
// pyramid
vector<string> pyramids = BZWParser::findSections("pyramid", chunks);
vector<pyramid> pyramidData;
if(pyramids[0] != BZW_NOT_FOUND) {
for(vector<string>::iterator i = pyramids.begin(); i != pyramids.end(); i++) {
pyramid tmp = pyramid();
if(!tmp.update(*i))
return 0;
pyramidData.push_back( tmp );
}
}
// sphere
vector<string> spheres = BZWParser::findSections("sphere", chunks);
vector<sphere> sphereData;
if(spheres[0] != BZW_NOT_FOUND) {
for(vector<string>::iterator i = spheres.begin(); i != spheres.end(); i++) {
sphere tmp = sphere();
if(!tmp.update(*i))
return 0;
sphereData.push_back( tmp );
}
}
// teleporter
vector<string> teleporters = BZWParser::findSections("teleporter", chunks);
vector<teleporter> teleporterData;
if(teleporters[0] != BZW_NOT_FOUND) {
for(vector<string>::iterator i = teleporters.begin(); i != teleporters.end(); i++) {
teleporter tmp = teleporter();
if(!tmp.update(*i))
return 0;
teleporterData.push_back( tmp );
}
}
// tetra
vector<string> tetras = BZWParser::findSections("tetra", chunks);
vector<tetra> tetraData;
if(tetras[0] != BZW_NOT_FOUND) {
for(vector<string>::iterator i = tetras.begin(); i != tetras.end(); i++) {
tetra tmp = tetra();
if(!tmp.update(*i))
return 0;
tetraData.push_back( tmp );
}
}
// base-class update (must be done BEFORE commiting new objects)
if(!DataEntry::update(data)) {
return 0;
}
// commit name
name = names[0];
// free previous objects
objects.clear();
// commit arcs
if(arcData.size() > 0) {
for(vector<arc>::iterator i = arcData.begin(); i != arcData.end(); i++) {
objects.push_back( new arc(*i) );
}
}
// commit bases
if(baseData.size() > 0) {
for(vector<base>::iterator i = baseData.begin(); i != baseData.end(); i++) {
objects.push_back( new base(*i) );
}
}
// commit boxes
if(boxData.size() > 0) {
for(vector<box>::iterator i = boxData.begin(); i != boxData.end(); i++) {
objects.push_back( new box(*i) );
}
}
// commit cones
if(coneData.size() > 0) {
for(vector<cone>::iterator i = coneData.begin(); i != coneData.end(); i++) {
objects.push_back( new cone(*i) );
}
}
// commit groups
if(groupData.size() > 0) {
for(vector<group>::iterator i = groupData.begin(); i != groupData.end(); i++) {
objects.push_back( new group(*i) );
}
}
// commit meshes
if(meshData.size() > 0) {
for(vector<mesh>::iterator i = meshData.begin(); i != meshData.end(); i++) {
objects.push_back( new mesh(*i) );
}
}
// commit meshboxes
if(meshboxData.size() > 0) {
for(vector<meshbox>::iterator i = meshboxData.begin(); i != meshboxData.end(); i++) {
objects.push_back( new meshbox(*i) );
}
}
// commit meshpyrs
if(meshpyrData.size() > 0) {
for(vector<meshpyr>::iterator i = meshpyrData.begin(); i != meshpyrData.end(); i++) {
objects.push_back( new meshpyr(*i) );
}
}
// commit pyramids
if(pyramidData.size() > 0) {
for(vector<pyramid>::iterator i = pyramidData.begin(); i != pyramidData.end(); i++) {
objects.push_back( new pyramid(*i) );
}
}
// commit spheres
if(sphereData.size() > 0) {
for(vector<sphere>::iterator i = sphereData.begin(); i != sphereData.end(); i++) {
objects.push_back( new sphere(*i) );
}
}
// commit teleporters
if(teleporterData.size() > 0) {
for(vector<teleporter>::iterator i = teleporterData.begin(); i != teleporterData.end(); i++) {
objects.push_back( new teleporter(*i) );
}
}
// commit tetras
if(tetraData.size() > 0) {
for(vector<tetra>::iterator i = tetraData.begin(); i != tetraData.end(); i++) {
objects.push_back( new tetra(*i) );
}
}
return 1;
}
////////////////////////////////////////////////////////////////////////
///
/// @fn VisiteurCollision::visiter(NoeudPortail& noeud)
///
/// Fonction qui permet de taiter la collision entre la
/// rondelle et les portails
///
/// @param[in] typeNoeud : Le type du noeud.
///
/// @return Aucun
///
////////////////////////////////////////////////////////////////////////
void VisiteurCollision::visiter(NoeudPortail& noeud)
{
/// fistances entre la rondelle et le portail
GLdouble dx = noeud.obtenirPositionRelative()[X] - rondelle_->obtenirPositionRelative()[X];
GLdouble dy = noeud.obtenirPositionRelative()[Y] - rondelle_->obtenirPositionRelative()[Y];
/// vecteur de la direction qui pointe de la rondelle au portail
Vecteur3 direction = Vecteur3(dx,dy,0);
direction.normaliser();
/// calcul de la distance entre deux points
GLdouble distance = sqrt( (dx*dx) + (dy*dy) );
/// savoir si la rondelle est dans le champs d'attraction
GLdouble distAttraction = distance - noeud.obtenirRayonAttraction() - rondelle_->obtenirRayon();
/// prendre en compte les rayons de nos objets
distance = distance - rondelle_->obtenirRayon();
/// si il y a collision, teleportation
if (distance < 0)
{
size_t nombrePortails = portails_.size();
if (nombrePortails == 1.0) // il y a juste un portail
{
noeud.desactiverAttraction();
}
else
{
if (noeud.obtenirAttraction())
{
GestionnaireSon::obtenirInstance()->jouerSonCollision(ArbreRenduINF2990::NOM_PORTAIL);
teleporter(noeud);
}
}
}
/// si il n'y a pas de collision, attirer la rondelle quand la rondelle est dans la zone d'attraction
else
{
if (distAttraction < 0.0)
{
if (distance > 1.0f)
noeud.varierRotation(1.0f / (GLfloat)distance * 10.0f);
else
noeud.varierRotation((GLfloat)distance + 1.0f);
if (noeud.obtenirAttraction())
{
Vecteur3 vitesse = rondelle_->obtenirVitesse();
for (int i = 0; i < 2; ++i) {
vitesse[i] += direction[i] * (noeud.obtenirRayon()*FORCE_PORTAIL/distance);
}
rondelle_->modifierVitesse(vitesse);
}
}
else
{
if (portails_.size() > 1)
noeud.activerAttraction();
}
}
}
