Exemple #1
0
void Game::disconnectPlayer(AbstractPlayer *p){
    disconnect(p, SIGNAL(onMoved(DIRECTION::Direction)), this, SLOT(playerMoved(DIRECTION::Direction)));
    disconnect(p, SIGNAL(onBomb()), this, SLOT(playerBomb()));
    disconnect(p, SIGNAL(onLeave()), this, SLOT(playerGone()));
    delete p;
    this->players.removeAll(p);
}
Exemple #2
0
void Thread::runCallback()
{
	if(onEnter())
	{
		// Esegue il thread
		run();
	}

	onLeave();
}
Elevator::Elevator(Simulation& simulation, int number, QGraphicsScene &scene, const QPolygonF &elevatorPolygon) :
    mSimulation(simulation),
    mNumber(number),
    mOccupancy(0),
    mState(NORMAL_STATE),
    mScene(scene),
    mPolygonItem(0),
    mTextItem(0),
    mEllipseItem(0),
    mAwayTextItem(0),
    mBrokenTextItem(0),
    mIsAllowedLeave(false),
    mIsSimulationStopped(false),
    mLeaveTimer(this)
{
    // Constructs leave timer
    mLeaveTimer.setSingleShot(true);
    QObject::connect(&mLeaveTimer, SIGNAL(timeout()), this, SLOT(onLeave()));

    // Polygon item
    mPolygonItem = mScene.addPolygon(elevatorPolygon);
    mPolygonItem->setPos( Simulation::ELEVATOR_SPACE + (mNumber * Simulation::ELEVATOR_FULL_WIDTH), 0 );
    mPolygonItem->setBrush(Qt::yellow);

    // Text item
    mTextItem = mScene.addText("0");
    centerTextItem();
    mTextItem->hide();

    // Ellipse item
    mEllipseItem = mScene.addEllipse(Simulation::ELEVATOR_SPACE + 15 + (mNumber * Simulation::ELEVATOR_FULL_WIDTH), 40,
                                     Simulation::PERSON_WIDTH, Simulation::PERSON_HEIGHT);
    mEllipseItem->setBrush(Qt::green);
    mEllipseItem->hide();

    // Away text item
    mAwayTextItem = mScene.addText("Away");
    centerAwayTextItem();
    mAwayTextItem->hide();

    // Broken text item
    mBrokenTextItem = mScene.addText("Broken");
    centerBrokenTextItem();
    mBrokenTextItem->hide();
}
Exemple #4
0
            /** accepts and keeps track of connections. reads data
              from connected peers and notifies through virtual methods
              if packets can be deserialized 
             \param tls use GnuTLS for encryption 
             \param port listen for incoming connections at this port
             \param maxPeers maximum number of connected peers */
            void serve(bool tls, int port, int maxPeers) {
                if (tls)
                    sock.reset(new TLSSocket());
                else
                    sock.reset(new Socket());
                sock->setNonBlocking();
                sock->bind(port);
                sock->listen(maxPeers);
                Select select;
                /* Wait for a peer, send data and term */
                while (!closed)
                {
                    select.reset();
                    if (peers.size() < maxPeers)
                        select.input(sock->getFd());
                    for (typename Peers::iterator i = peers.begin(); i != peers.end(); i++) {
                        select.input((*i)->getFd());
                    }
                    if (select.select(100) == -1)
                        continue;
                    if (select.canRead(sock->getFd()) 
                            && peers.size() < maxPeers) {
                        try {
                            Socket* csock = sock->accept();

                            if (tls)  {
                                boost::threadpool::schedule(pool, 
                                        boost::bind(&Server::handshake, this, csock));
                            } else {
                                peers.push_back(boost::shared_ptr<PeerT>(new PeerT()));
                                csock->setNonBlocking();
                                peers.back()->setup(csock);
                                onJoin(*peers.back());

                            }
                        } catch (SocketExcept& e) {
                            std::cerr << e.what() << std::endl;
                        }
                    }
                    if (tls)  {
                        Socket* sock = NULL;
                        socketsReady.try_pop_front(sock);
                        if (sock) {
                            sock->setNonBlocking();
                            peers.push_back(boost::shared_ptr<PeerT>(new PeerT()));
                            peers.back()->setup(sock);
                            onJoin(*peers.back());
                        }
                    }
                    for (size_t i = 0; i < peers.size(); i++) {
                        boost::shared_ptr<PeerT>& p = peers[i];
                        if (select.canRead(p->getFd()))
                            p->onInput();
                        while (p->hasPacket()) {
                            onPacket(*p);
                        }
                    }
                    // collect dead peers
                    size_t count = peers.size();
                    for (size_t i = 0; i < count; ) {
                        if (!peers[i]->isActive()) {
                            onLeave(*peers[i]);

                            peers[i] = peers[peers.size() - 1];
                            count--;
                        } else
                            i++;
                    }
                    if (count < peers.size()) {
                        peers.resize(count);
                    }

                }
            }
Elevator::~Elevator()
{
    QObject::disconnect(&mLeaveTimer, SIGNAL(timeout()), this, SLOT(onLeave()));
}
Exemple #6
0
void MenuMaker::input(int key) {
	if (currentMenu->entries->size()==0 && ! (key == MENUMAKER_INPUT_LEFT || key == MENUMAKER_INPUT_BACK))
		return;
		
	switch(key) {
		case MENUMAKER_INPUT_UP:
				
			if (currentEntry <= 0)
				currentEntry = currentMenu->entries->size()-1;
			// TODO else if (rollover)
			else currentEntry--;
			break;

		case MENUMAKER_INPUT_DOWN:
			if (currentEntry >= currentMenu->entries->size()-1)
				currentEntry = 0;
			else currentEntry++;
			break;
			
		case MENUMAKER_INPUT_LEFT:
			// TODO
			// if in widget:
			// decrease()
			// else if in menu
			input(MENUMAKER_INPUT_BACK);
			return;
			
		case MENUMAKER_INPUT_RIGHT:
			// TODO
			// if in widget:
			// increase()
			// else if in menu
			input(MENUMAKER_INPUT_SELECT);
			return;
			
		case MENUMAKER_INPUT_BACK: {
				if (history->size() <= 0)
					return;
				
				MenuMakerMenu* b = history->pop();
				MenuMakerMenu* oldMenu = currentMenu;
				const int oid = currentMenu->id;
				int from = 0;
				const int n = b->entries->size();
				for (int i=0;i<n;i++) {
					if (b->entries->get(i)->id == oid) {
						from = i;
						break;
					}
				}
				
				onLeave(oldMenu);
				currentEntry = from;
				currentMenu = b;
				redraw();

				onExit(oldMenu);
				
				return; // return, no break. this is select/back not navigation within the current list;
			}
			
		case MENUMAKER_INPUT_SELECT: 
		{
			MenuMakerEntry* e = currentMenu->entries->get(currentEntry);
			MenuMakerMenu* m;
			switch(e->type) { // Jaguar
				case MENUMAKER_TYPE_SUBMENU:
					m = resolveMenu(e->id);
					onPrepare(m);
					select(m);
					break;
				case MENUMAKER_TYPE_SELECT_SINGLE: {
					int old = *((int*)currentMenu->choice);
					*((int*)currentMenu->choice) = e->id;
					onSelection(currentMenu, &old);
					break; }
				case MENUMAKER_TYPE_SELECT_MULTI: {
					bool old[currentMenu->entries->size()];
					memcpy(old, currentMenu->choice, sizeof(bool) * currentMenu->entries->size());
					((bool*)currentMenu->choice)[currentEntry] = !((bool*)currentMenu->choice)[currentEntry];
					onSelection(currentMenu, old);
					}
					break;
				default:
					onEntry(e->id);
					break;
			}
			return; // return, no break. this is select/back not navigation within the current list
		}
		
		default:
			return;
	}

	highlight(currentEntry);
}
Exemple #7
0
void Game::connectPlayer(AbstractPlayer *p){
    this->players.append(p);
    connect(p, SIGNAL(onMoved(DIRECTION::Direction)), this, SLOT(playerMoved(DIRECTION::Direction)));
    connect(p, SIGNAL(onBomb()), this, SLOT(playerBomb()));
    connect(p, SIGNAL(onLeave()), this, SLOT(playerGone()));
}