Exemple #1
0
void Circuit::removeElement(v3s16 pos) {
	JMutexAutoLock lock(m_elements_mutex);

	std::vector <std::list <CircuitElementVirtual>::iterator> virtual_elements_for_update;
	std::list <CircuitElement>::iterator current_element = m_pos_to_iterator[pos];
	m_database->del(itos(current_element->getId()));

	current_element->getNeighbors(virtual_elements_for_update);

	m_elements.erase(current_element);

	for(std::vector <std::list <CircuitElementVirtual>::iterator>::iterator i = virtual_elements_for_update.begin();
	        i != virtual_elements_for_update.end(); ++i) {
		if((*i)->size() > 1) {
			std::ostringstream out(std::ios_base::binary);
			(*i)->serialize(out);
			m_virtual_database->put(itos((*i)->getId()), out.str());
		} else {
			m_virtual_database->del(itos((*i)->getId()));
			std::list <CircuitElement>::iterator element_to_save;
			for(std::list <CircuitElementVirtualContainer>::iterator j = (*i)->begin(); j != (*i)->end(); ++j) {
				element_to_save = j->element_pointer;
			}
			m_virtual_elements.erase(*i);
			saveElement(element_to_save, false);
		}
	}

	m_pos_to_iterator.erase(pos);
}
Exemple #2
0
void QGUISkin::saveDamage()
{
    pfGUISkin* skin = pfGUISkin::Convert(fCreatable);

    skin->setItemMargin(fItemMargin->value());
    skin->setBorderMargin(fBorderMargin->value());
    saveElement();
}
Exemple #3
0
void QGUISkin::setElement(int which)
{
    pfGUISkin* skin = pfGUISkin::Convert(fCreatable);
    saveElement();

    fCurElement = which;
    fX->setValue(skin->getElement(fCurElement).fX);
    fY->setValue(skin->getElement(fCurElement).fY);
    fWidth->setValue(skin->getElement(fCurElement).fWidth);
    fHeight->setValue(skin->getElement(fCurElement).fHeight);
}
Exemple #4
0
void Circuit::updateElement(MapNode& node, v3s16 pos, INodeDefManager* ndef, const unsigned char* func) {
	if(!m_updating_process) {
		m_elements_mutex.Lock();
	}

	std::list <CircuitElement>::iterator current_element = m_pos_to_iterator[pos];
	std::pair<const unsigned char*, unsigned long> node_func;
	if(ndef->get(node).param_type_2 == CPT2_FACEDIR) {
		node_func = m_circuit_elements_states.addState(func, node.param2);
	} else {
		node_func = m_circuit_elements_states.addState(func);
	}
	current_element->setFunc(node_func.first, node_func.second);
	current_element->setDelay(ndef->get(node).circuit_element_delay);
	saveCircuitElementsStates();
	saveElement(current_element, false);

	if(!m_updating_process) {
		m_elements_mutex.Unlock();
	}
}
Exemple #5
0
void Circuit::addElement(Map& map, INodeDefManager* ndef, v3s16 pos, const unsigned char* func) {
	JMutexAutoLock lock(m_elements_mutex);

	bool already_existed[6];
	bool connected_faces[6] = {0};

	std::vector <std::pair <std::list <CircuitElement>::iterator, int > > connected;
	MapNode node = map.getNode(pos);

	std::pair <const unsigned char*, unsigned long> node_func;
	if(ndef->get(node).param_type_2 == CPT2_FACEDIR) {
		// If block is rotatable, then rotate it's function.
		node_func = m_circuit_elements_states.addState(func, node.param2);
	} else {
		node_func = m_circuit_elements_states.addState(func);
	}
	saveCircuitElementsStates();
	std::list <CircuitElement>::iterator current_element_iterator =
	    m_elements.insert(m_elements.begin(), CircuitElement(pos, node_func.first, node_func.second,
	                      m_max_id++, ndef->get(node).circuit_element_delay));
	m_pos_to_iterator[pos] = current_element_iterator;

	// For each face add all other connected faces.
	for(int i = 0; i < 6; ++i) {
		if(!connected_faces[i]) {
			connected.clear();
			CircuitElement::findConnectedWithFace(connected, map, ndef, pos, SHIFT_TO_FACE(i), m_pos_to_iterator, connected_faces);
			if(connected.size() > 0) {
				std::list <CircuitElementVirtual>::iterator virtual_element_it;
				bool found = false;
				for(std::vector <std::pair <std::list <CircuitElement>::iterator, int> >::iterator j = connected.begin();
				        j != connected.end(); ++j) {
					if(j->first->getFace(j->second).is_connected) {
						virtual_element_it = j->first->getFace(j->second).list_pointer;
						found = true;
						break;
					}
				}

				// If virtual element already exist
				if(found) {
					already_existed[i] = true;
				} else {
					already_existed[i] = false;
					virtual_element_it = m_virtual_elements.insert(m_virtual_elements.begin(),
					                     CircuitElementVirtual(m_max_virtual_id++));
				}

				std::list <CircuitElementVirtualContainer>::iterator it;
				for(std::vector <std::pair <std::list <CircuitElement>::iterator, int> >::iterator j = connected.begin();
				        j != connected.end(); ++j) {
					if(!j->first->getFace(j->second).is_connected) {
						it = virtual_element_it->insert(virtual_element_it->begin(), CircuitElementVirtualContainer());
						it->shift = j->second;
						it->element_pointer = j->first;
						j->first->connectFace(j->second, it, virtual_element_it);
					}
				}
				it = virtual_element_it->insert(virtual_element_it->begin(), CircuitElementVirtualContainer());
				it->shift = i;
				it->element_pointer = current_element_iterator;
				current_element_iterator->connectFace(i, it, virtual_element_it);
			}

		}
	}

	for(int i = 0; i < 6; ++i) {
		if(current_element_iterator->getFace(i).is_connected && !already_existed[i]) {
			saveVirtualElement(current_element_iterator->getFace(i).list_pointer, true);
		}
	}
	saveElement(current_element_iterator, true);
}
Exemple #6
0
void Circuit::processElementsQueue(Map& map, INodeDefManager* ndef) {
	if(m_elements_queue.size() > 0) {
		JMutexAutoLock lock(m_elements_mutex);

		std::vector <std::pair <std::list <CircuitElement>::iterator, int> > connected;
		std::vector <std::list <CircuitElementVirtual>::iterator> created_virtual_elements;
		MapNode node;
		bool connected_faces[6];

		// Filling with empty elements
		for(unsigned int i = 0; i < m_elements_queue.size(); ++i) {
			node = map.getNode(m_elements_queue[i]);
			std::pair <const unsigned char*, unsigned long> node_func;
			if(ndef->get(node).param_type_2 == CPT2_FACEDIR) {
				node_func = m_circuit_elements_states.addState(ndef->get(node).circuit_element_states, node.param2);
			} else {
				node_func = m_circuit_elements_states.addState(ndef->get(node).circuit_element_states);
			}
			m_pos_to_iterator[m_elements_queue[i]] = m_elements.insert(m_elements.begin(),
			        CircuitElement(m_elements_queue[i],
			                       node_func.first, node_func.second,
			                       m_max_id++, ndef->get(node).circuit_element_delay));
		}

		for(unsigned int i = 0; i < m_elements_queue.size(); ++i) {
			v3s16 pos = m_elements_queue[i];
			std::list <CircuitElement>::iterator current_element_it = m_pos_to_iterator[pos];
			for(int j = 0; j < 6; ++j) {
				connected_faces[j] = false;
			}
			for(int j = 0; j < 6; ++j) {
				if(!current_element_it->getFace(j).is_connected && !connected_faces[j]) {
					connected.clear();
					CircuitElement::findConnectedWithFace(connected, map, ndef, pos, SHIFT_TO_FACE(j),
					                                      m_pos_to_iterator, connected_faces);

					if(!connected.empty()) {
						std::list <CircuitElementVirtual>::iterator virtual_element_it;
						bool found = false;
						for(std::vector <std::pair <std::list <CircuitElement>::iterator, int> >::iterator k = connected.begin();
						        k != connected.end(); ++k) {
							if(k->first->getFace(k->second).is_connected) {
								virtual_element_it = k->first->getFace(k->second).list_pointer;
								found = true;
								break;
							}
						}

						if(!found) {
							virtual_element_it = m_virtual_elements.insert(m_virtual_elements.begin(),
							                     CircuitElementVirtual(m_max_virtual_id++));
						}

						std::list <CircuitElementVirtualContainer>::iterator it;
						for(std::vector <std::pair <std::list <CircuitElement>::iterator, int> >::iterator k = connected.begin();
						        k != connected.end(); ++k) {
							if(!k->first->getFace(k->second).is_connected) {
								it = virtual_element_it->insert(virtual_element_it->begin(), CircuitElementVirtualContainer());
								it->shift = k->second;
								it->element_pointer = k->first;
								k->first->connectFace(k->second, it, virtual_element_it);
							}
						}
						it = virtual_element_it->insert(virtual_element_it->begin(), CircuitElementVirtualContainer());
						it->shift = j;
						it->element_pointer = current_element_it;
						current_element_it->connectFace(j, it, virtual_element_it);
					}
				}
			}
		}

		for(unsigned int i = 0; i < created_virtual_elements.size(); ++i) {
			saveVirtualElement(created_virtual_elements[i], true);
		}

		for(unsigned int i = 0; i < m_elements_queue.size(); ++i) {
			saveElement(m_pos_to_iterator[m_elements_queue[i]], false);
		}

		m_elements_queue.clear();

		saveCircuitElementsStates();

	}
}
Exemple #7
0
void Circuit::removeWire(Map& map, INodeDefManager* ndef, v3s16 pos, MapNode& node) {
	JMutexAutoLock lock(m_elements_mutex);

	std::vector <std::pair <std::list <CircuitElement>::iterator, int> > current_face_connected;

	bool connected_faces[6];
	for(int i = 0; i < 6; ++i) {
		connected_faces[i] = false;
	}

	// Find and remove virtual elements
	bool found_virtual_elements = false;
	for(int i = 0; i < 6; ++i) {
		if(!connected_faces[i]) {
			current_face_connected.clear();
			CircuitElement::findConnectedWithFace(current_face_connected, map, ndef, pos,
			                                      SHIFT_TO_FACE(i), m_pos_to_iterator, connected_faces);
			for(unsigned int j = 0; j < current_face_connected.size(); ++j) {
				CircuitElementContainer current_edge = current_face_connected[j].first->getFace(current_face_connected[j].second);
				if(current_edge.is_connected) {
					found_virtual_elements = true;
					m_virtual_database->del(itos(current_edge.list_pointer->getId()));

					m_virtual_elements.erase(current_edge.list_pointer);
					break;
				}
			}

			for(unsigned int j = 0; j < current_face_connected.size(); ++j) {
				saveElement(current_face_connected[j].first, false);
			}

		}
	}

	for(int i = 0; i < 6; ++i) {
		connected_faces[i] = false;
	}

	if(found_virtual_elements) {
		// Restore some previously deleted connections.
		for(int i = 0; i < 6; ++i) {
			if(!connected_faces[i]) {
				current_face_connected.clear();
				CircuitElement::findConnectedWithFace(current_face_connected, map, ndef, pos, SHIFT_TO_FACE(i),
				                                      m_pos_to_iterator, connected_faces);

				if(current_face_connected.size() > 1) {
					std::list <CircuitElementVirtual>::iterator new_virtual_element = m_virtual_elements.insert(
					            m_virtual_elements.begin(), CircuitElementVirtual(m_max_virtual_id++));

					for(unsigned int j = 0; j < current_face_connected.size(); ++j) {
						std::list <CircuitElementVirtualContainer>::iterator new_container = new_virtual_element->insert(
						            new_virtual_element->begin(), CircuitElementVirtualContainer());
						new_container->element_pointer = current_face_connected[j].first;
						new_container->shift = current_face_connected[j].second;
						current_face_connected[j].first->connectFace(current_face_connected[j].second,
						        new_container, new_virtual_element);

						saveElement(current_face_connected[j].first, false);
					}

					saveVirtualElement(new_virtual_element, false);
				}
			}
		}
	}
}