C++ Hexagon类代码示例

// Updates the player and checks if the player is in a safe zone.
void Territory::updatePlayer(UpdateInfo info, Controls * controls)
{
	player->update(info, controls);
	player->setIsInSafeZone(false);

	// Check if the player is in a safe zone.
	for (int i = 0; i < 6 && !player->getIsInSafeZone(); i++)
	{
		for (int j = 0; j < safeZonesTiles[i].size(); j++)
		{
			Hexagon * tile = safeZonesTiles[i][j];

			if (Collision::hitBoxesOverlap(tile->getBoundingBox(), Vector2f(), player->getBoundingBox(), player->getSpeed()))
			{
				std::list<Vector2f> penetration;

				if (SAT::collides(player->getConvexHull(), tile->getConvexHull(), player->getSpeed(), penetration))
				{
					player->setIsInSafeZone(true);
					player->setSafeZoneIndex(i);

					break;
				}
			}
		}
	}
}

// Caution: Can possibly deactivate this territory and activate another.
void Territory::collideBorderTiles()
{
	for (int i = 0; i < borderCoordinates.size(); i++)
	{
		Hexagon * tile = floorTiles[borderCoordinates[i].q][borderCoordinates[i].r];

		if (Collision::hitBoxesOverlap(tile->getBoundingBox(), player->getBoundingBox(), player->getSpeed()))
		{
			std::list<Vector2f> penetration;

			if (SAT::collides(player->getConvexHull(), tile->getConvexHull(), player->getSpeed(), penetration))
			{
				// Move the player into another territory if the player is in a safe zone.
				if (player->getIsInSafeZone())
				{
					Vector2f direction = Vector2fMath::unitVector(player->getPosition() - position);
					Vector2f seekPosition = position + (direction * radius * 1.1f);

					world->changeTerritory(seekPosition);

					break;
				}
				else
				{
					player->translate(SAT::getShortestPenetration(penetration));
				}
			}
		}
	}
}

void HexGrid::markNeighborBelow(Hexagon *h)
{
    Coord c = h->neighborCoord(3);
    Hexagon *neighbor = getHexagon(c);
    neighbor->setDenseNeighbor(0);
    if (neighbor->dense() && !neighbor->possibleRoot())
        m_pos_roots.erase(neighbor);
}

bool HelloWorld::ccTouchBegan (CCTouch *pTouch, CCEvent *pEvent)
{
    Hexagon h = line.CCP2Hex (this->convertTouchToNodeSpace (pTouch));
    h.color = ccc4f (1, 0, 1, 1);
    h.Integerlize();
    line.hexagones.push_back (h);

    return true;
}

void HelloWorld::ccTouchMoved (CCTouch *pTouch, CCEvent *pEvent)
{
    line.hexagones.erase (line.hexagones.begin() + 1, line.hexagones.end());
    Hexagon h = field.CCP2Hex (this->convertTouchToNodeSpace (pTouch));
    h.Integerlize();
    line.MakeLine (line.hexagones[0], h, ccc4f (1, 0.5, 0.5, 1));
    intersection.hexagones.clear();
    intersection.MakeSolidHex (3, h, ccc4f (1, 1, 1, 1));
}

Hexagon Hexagon::Towards (const Hexagon& target) const
{
    Hexagon dir = target - *this;
    dir.Round();
    dir.Normalize();
    /* for (int i = 0; i < eDirection::COUNT; ++i)
     {
         if (dir == s_directions[i])
             return eDirection (i);
     }*/
    return dir;
}

void TroopsMover::shakeAround(const Hexagon *hex, int strength)
{
    const float dt = 0.75f;
   
    // Shake around
    for(int side = 0; side < HexSidesCount; ++side){
         Hexagon* h = Game::current().getBoard()->sideHexAt((HexSide)side, hex->getXCoord(), hex->getYCoord());
         if(h){
             h->shake(dt, strength);
         }
     }
    
    // shake all
    //Game::current().getBoard()->runAction(CCEaseIn::create(CCShake::actionWithDuration(dt, strength), dt));
}

void BeeHive::MakeLine (const Hexagon& start, const Hexagon& end, vector<Hexagon>& line, ccColor4F color /*= ccc4f(1, 1, 1, 1)*/)
{
    float N = start.Distance (end);
    if (N==0)return;
    for (int i = 0; i <= N; ++i)
    {
        Hexagon  h = (start * (1 - i / N) + end * i / N).Round();
        h.color = color;
        line.push_back (h);
    }
}

void HexGrid::findParentPath(Path *p)
{
    Segment s = p->rootSegment();
    Hexagon *h = s.hex();
    int y = h->y();
    while (y >= m_miny)
    {
        HexPathMap::iterator it = m_hex_paths.find(h);
        if (it != m_hex_paths.end())
        {
            Path *parentPath = it->second;
            if (parentPath == p->parent())
            {
               p->setParent(NULL);
            }
            else if (!p->parent() && parentPath != p)
            {
               p->setParent(parentPath);
            }
        }
        h = getHexagon(h->x(), --y);
    }
}

std::vector<Hexagon*> HexagonGrid::findPath(Hexagon* from, Hexagon* to)
{
    Hexagon* current = 0;
    std::vector<Hexagon*> result;
    std::priority_queue<Hexagon*, std::vector<Hexagon*>, HeuristicComparsion> unvisited;
    unsigned int cameFrom[200*200] = {};
    unsigned int costSoFar[200*200] = {};

    // if we can't go to the location
    // @todo remove when path will have lenght restriction
    if (!to->canWalkThru()) return result;

    unvisited.push(from);

    cameFrom[from->number()] = 0;
    costSoFar[from->number()] = 0;


    while (!unvisited.empty())
    {
        current = unvisited.top(); unvisited.pop();
        if (current == to) break;
        // search limit
        if (costSoFar[current->number()] >= 100) break;

        for (Hexagon* neighbor : *current->neighbors())
        {
            if (!neighbor->canWalkThru()) continue;

            unsigned int newCost = costSoFar[current->number()] + 1;
            if (!costSoFar[neighbor->number()] || newCost < costSoFar[neighbor->number()])
            {
                costSoFar[neighbor->number()] = newCost;
                neighbor->setHeuristic(distance(neighbor, to) + newCost);
                unvisited.push(neighbor);
                cameFrom[neighbor->number()] = current->number();
            }
        }
    }

    // found nothing
    if (current != to) return result;


    while (current->number() != from->number())
    {
        result.push_back(current);
        current = _hexagons.at(cameFrom[current->number()]);
    }

    return result;
}

void TroopsMover::moveTroops(Army* army, Hexagon* endHex)
{
    // used for achievements and shake
    const int armySize = army->getTroopsCount();
    const int endHexArmySize = endHex->getTroopsCount();
    Hexagon* startHex = army->getCurrentHex();
    
    const int troops = army->getTroopsCount();
    startHex->removeArmy(army);
    
    if(troops == 0){
        army->free();
        return;
    }
    
    if(endHex->getOwner() == startHex->getOwner()){
        endHex->addArmy(army);
    }else{
        
        AttackResult attackResult = getAttackResult(army, endHex);
        updateAchievements(army->getCurrentHex()->getOwner(), attackResult, armySize, endHexArmySize, endHex);
        handleAttackResult(attackResult, army, startHex, endHex);
        
        if(attackResult == DefenderWins){
            if(endHex->getOwner()) EffectPlayer::playAttackEffect();
        }
        
        checkAndShake(armySize, endHexArmySize, endHex);
        
    }
    
    if((endHex->getTroopsCount() > 0) && (startHex != endHex)){
        endHex->runScaleAction();
    }

}

void HexGrid::addPoint(Point p)
{
    Hexagon *h = findHexagon(p);
    if (!h->dense())
    {
        h->increment();
        if (dense(h))
        {
            h->setDense();
            m_miny = std::min(m_miny, h->y() - 1);
            if (h->possibleRoot())
            {
                m_pos_roots.insert(h);
            }
            markNeighborBelow(h);
        }
    }
}

void HexGrid::addPoint(Point p)
{
    if (m_width < 0)
    {
        m_sample.push_back(p);
        if (m_sample.size() >= m_maxSample)
            processSample();
        return;
    }

    Hexagon *h = findHexagon(p);
    h->increment();
    if (!h->dense())
    {
        if (dense(h))
        {
            h->setDense();
            m_miny = std::min(m_miny, h->y() - 1);
            if (h->possibleRoot())
                m_pos_roots.insert(h);
            markNeighborBelow(h);
        }
    }
}

float Hexagon::Distance (const Hexagon& h) const
{
    return max (max (abs (q - h.q), abs (r - h.r)), abs (y() - h.y()));
}