Example #1
0
/** 
 * @brief Parse Windows version data to string.
 * See info about how to determine Windows versions from URL:
 * http://msdn.microsoft.com/en-us/library/ms724833(VS.85).aspx
 * @return String describing Windows version.
 */
String CConfigLog::GetWindowsVer()
{
	OSVERSIONINFOEX osvi;
	String sVersion;

	// Try calling GetVersionEx using the OSVERSIONINFOEX structure.
	// If that fails, try using the OSVERSIONINFO structure.

	ZeroMemory(&osvi, sizeof(OSVERSIONINFOEX));
	osvi.dwOSVersionInfoSize = sizeof(OSVERSIONINFOEX);

	if( !GetVersionEx ((OSVERSIONINFO *) &osvi) )
	{
		osvi.dwOSVersionInfoSize = sizeof (OSVERSIONINFO);
		if (! GetVersionEx ( (OSVERSIONINFO *) &osvi) )
			return _T("");
	}

	switch (osvi.dwPlatformId)
	{
		// Test for the Windows NT product family.
		case VER_PLATFORM_WIN32_NT:

		// Test for the specific product family.
		if ( osvi.dwMajorVersion == 5 && osvi.dwMinorVersion == 2 )
			sVersion = _T("Microsoft Windows Server 2003 family, ");
		else if ( osvi.dwMajorVersion == 5 && osvi.dwMinorVersion == 1 )
			sVersion = _T("Microsoft Windows XP ");
		else if ( osvi.dwMajorVersion == 5 && osvi.dwMinorVersion == 0 )
			sVersion = _T("Microsoft Windows 2000 ");
		else if ( osvi.dwMajorVersion <= 4 )
			sVersion = _T("Microsoft Windows NT ");
		else if ( osvi.dwMajorVersion == 6 && osvi.dwMinorVersion == 0 )
		{
			if (osvi.wProductType == VER_NT_WORKSTATION)
				sVersion = _T("Microsoft Windows Vista ");
			else
				sVersion = _T("Microsoft Windows Server 2008 ");
		}
		else if ( osvi.dwMajorVersion == 6 && osvi.dwMinorVersion == 1 )
		{
			if (osvi.wProductType == VER_NT_WORKSTATION)
				sVersion = _T("Microsoft Windows 7 ");
			else
				sVersion = _T("Microsoft Windows Server 2008 R2 ");
		}
		else if ( osvi.dwMajorVersion == 6 && osvi.dwMinorVersion == 2 )
		{
			if (osvi.wProductType == VER_NT_WORKSTATION)
				sVersion = _T("Microsoft Windows 8 ");
			else
				sVersion = _T("Microsoft Windows Server 2012 ");
		}
		else
			sVersion = string_format(_T("[? WindowsNT %d.%d] "), 
				osvi.dwMajorVersion, osvi.dwMinorVersion);

		if (osvi.dwOSVersionInfoSize == sizeof(OSVERSIONINFOEX))
		{
			// Test for specific product on Windows NT 4.0 SP6 and later.
			String sProduct = GetProductFromOsvi(osvi);
			sVersion += sProduct;
		}
		else
		{
			// Test for specific product on Windows NT 4.0 SP5 and earlier
			String sProduct = GetNtProductFromRegistry(osvi);
			sVersion += sProduct;
		}

		// Display service pack (if any) and build number.
		if( osvi.dwMajorVersion == 4 &&
			_tcsicmp( osvi.szCSDVersion, _T("Service Pack 6") ) == 0 )
		{
			HKEY hKey;
			LONG lRet;

			// Test for SP6 versus SP6a.
			lRet = RegOpenKeyEx( HKEY_LOCAL_MACHINE,
				_T("SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion\\Hotfix\\Q246009"),
				0, KEY_QUERY_VALUE, &hKey );
			String ver;
			if( lRet == ERROR_SUCCESS )
				ver = string_format(_T("Service Pack 6a (Build %d)"), osvi.dwBuildNumber & 0xFFFF );
			else // Windows NT 4.0 prior to SP6a
			{
				ver = string_format(_T("%s (Build %d)"),
					osvi.szCSDVersion,
					osvi.dwBuildNumber & 0xFFFF);
			}

			sVersion += ver;
			RegCloseKey( hKey );
		}
		else // Windows NT 3.51 and earlier or Windows 2000 and later
		{
			String ver = string_format( _T("%s (Build %d)"),
				osvi.szCSDVersion,
				osvi.dwBuildNumber & 0xFFFF);
			sVersion += ver;
		}
		break;

	// Test for the Windows 95 product family.
	case VER_PLATFORM_WIN32_WINDOWS:

		if (osvi.dwMajorVersion == 4 && osvi.dwMinorVersion == 0)
		{
			sVersion = _T("Microsoft Windows 95 ");
			if ( osvi.szCSDVersion[1] == 'C' || osvi.szCSDVersion[1] == 'B' )
				sVersion += _T("OSR2 " );
		}
		else if (osvi.dwMajorVersion == 4 && osvi.dwMinorVersion == 10)
		{
			sVersion = _T("Microsoft Windows 98 ");
			if ( osvi.szCSDVersion[1] == 'A' )
				sVersion += _T("SE " );
		}
		else if (osvi.dwMajorVersion == 4 && osvi.dwMinorVersion == 90)
		{
			sVersion = _T("Microsoft Windows Millennium Edition");
		}
		else
		{
			sVersion = string_format(_T("[? Windows9x %d.%d] "), 
				osvi.dwMajorVersion, osvi.dwMinorVersion);
		}
		break;

	case VER_PLATFORM_WIN32s:
		sVersion = _T("Microsoft Win32s\r\n");
		break;

	default:
		sVersion = string_format(_T(" [? Windows? %d.%d] "),
			osvi.dwMajorVersion, osvi.dwMinorVersion);
	}
	return sVersion;
}
void GL1TextureProvider::to_opengl_textureformat(TextureFormat format, GLint &gl_internal_format, GLenum &gl_pixel_format)
{
    switch (format)
    {
    // base internal format

    // sized internal format

    // TODO: Should this really be here?
    case tf_stencil_index1:
        gl_internal_format = GL_STENCIL_INDEX1;
        gl_pixel_format = GL_STENCIL_INDEX;
        break;
    case tf_stencil_index4:
        gl_internal_format = GL_STENCIL_INDEX4;
        gl_pixel_format = GL_STENCIL_INDEX;
        break;
    case tf_stencil_index8:
        gl_internal_format = GL_STENCIL_INDEX8;
        gl_pixel_format = GL_STENCIL_INDEX;
        break;
    case tf_stencil_index16:
        gl_internal_format = GL_STENCIL_INDEX16;
        gl_pixel_format = GL_STENCIL_INDEX;
        break;

    //case tf_r8: gl_internal_format = GL_R8; gl_pixel_format = GL_RED; break;
    //case tf_r8_snorm: gl_internal_format = GL_R8_SNORM; gl_pixel_format = GL_RED; break;
    //case tf_r16: gl_internal_format = GL_R16; gl_pixel_format = GL_RED; break;
    //case tf_r16_snorm: gl_internal_format = GL_R16_SNORM; gl_pixel_format = GL_RED; break;
    //case tf_rg8: gl_internal_format = GL_RG8; gl_pixel_format = GL_RG; break;
    //case tf_rg8_snorm: gl_internal_format = GL_RG8_SNORM; gl_pixel_format = GL_RG; break;
    //case tf_rg16: gl_internal_format = GL_RG16; gl_pixel_format = GL_RG; break;
    //case tf_rg16_snorm: gl_internal_format = GL_RG16_SNORM; gl_pixel_format = GL_RG; break;
    case tf_r3_g3_b2:
        gl_internal_format = GL_R3_G3_B2;
        gl_pixel_format = GL_RGB;
        break;
    case tf_rgb4:
        gl_internal_format = GL_RGB4;
        gl_pixel_format = GL_RGB;
        break;
    case tf_rgb5:
        gl_internal_format = GL_RGB5;
        gl_pixel_format = GL_RGB;
        break;
    case tf_rgb8:
        gl_internal_format = GL_RGB8;
        gl_pixel_format = GL_RGB;
        break;
    case tf_rgb10:
        gl_internal_format = GL_RGB10;
        gl_pixel_format = GL_RGB;
        break;
    case tf_rgb12:
        gl_internal_format = GL_RGB12;
        gl_pixel_format = GL_RGB;
        break;
    case tf_rgb16:
        gl_internal_format = GL_RGB16;
        gl_pixel_format = GL_RGB;
        break;
    //case tf_rgb16_snorm: gl_internal_format = GL_RGB16_SNORM; gl_pixel_format = GL_RGB; break;
    case tf_rgba2:
        gl_internal_format = GL_RGBA2;
        gl_pixel_format = GL_RGBA;
        break;
    case tf_rgba4:
        gl_internal_format = GL_RGBA4;
        gl_pixel_format = GL_RGBA;
        break;
    case tf_rgb5_a1:
        gl_internal_format = GL_RGB5_A1;
        gl_pixel_format = GL_RGBA;
        break;
    case tf_rgba8:
        gl_internal_format = GL_RGBA8;
        gl_pixel_format = GL_RGBA;
        break;
    case tf_bgra8:
        gl_internal_format = GL_RGBA8;
        gl_pixel_format = GL_BGRA;
        break;
    case tf_bgr8:
        gl_internal_format = GL_RGB8;
        gl_pixel_format = GL_BGR;
        break;
    //case tf_rgba8_snorm: gl_internal_format = GL_RGBA8_SNORM; gl_pixel_format = GL_RGBA; break;
    case tf_rgb10_a2:
        gl_internal_format = GL_RGB10_A2;
        gl_pixel_format = GL_RGBA;
        break;
    case tf_rgba12:
        gl_internal_format = GL_RGBA12;
        gl_pixel_format = GL_RGBA;
        break;
    case tf_rgba16:
        gl_internal_format = GL_RGBA16;
        gl_pixel_format = GL_RGBA;
        break;
    //case tf_rgba16_snorm: gl_internal_format = GL_RGBA16_SNORM; gl_pixel_format = GL_RGBA; break;
    //case tf_srgb8: gl_internal_format = GL_SRGB8; gl_pixel_format = GL_RGB; break;
    //case tf_srgb8_alpha8: gl_internal_format = GL_SRGB8_ALPHA8; gl_pixel_format = GL_RGBA; break;
    //case tf_r16f: gl_internal_format = GL_R16F; gl_pixel_format = GL_RED; break;
    //case tf_rg16f: gl_internal_format = GL_RG16F; gl_pixel_format = GL_RG; break;
    //case tf_rgb16f: gl_internal_format = GL_RGB16F; gl_pixel_format = GL_RGB; break;
    //case tf_rgba16f: gl_internal_format = GL_RGBA16F; gl_pixel_format = GL_RGBA; break;
    //case tf_r32f: gl_internal_format = GL_R32F; gl_pixel_format = GL_RED; break;
    //case tf_rg32f: gl_internal_format = GL_RG32F; gl_pixel_format = GL_RG; break;
    //case tf_rgb32f: gl_internal_format = GL_RGB32F; gl_pixel_format = GL_RGB; break;
    //case tf_rgba32f: gl_internal_format = GL_RGBA32F; gl_pixel_format = GL_RGBA; break;
    //case tf_r11f_g11f_b10f: gl_internal_format = GL_R11F_G11F_B10F; gl_pixel_format = GL_RGB; break;
    //case tf_rgb9_e5: gl_internal_format = GL_RGB9_E5; gl_pixel_format = GL_RGB; break;
    //case tf_r8i: gl_internal_format = GL_R8I; gl_pixel_format = GL_RED; break;
    //case tf_r8ui: gl_internal_format = GL_R8UI; gl_pixel_format = GL_RED; break;
    //case tf_r16i: gl_internal_format = GL_R16I; gl_pixel_format = GL_RED; break;
    //case tf_r16ui: gl_internal_format = GL_R16UI; gl_pixel_format = GL_RED; break;
    //case tf_r32i: gl_internal_format = GL_R32I; gl_pixel_format = GL_RED; break;
    //case tf_r32ui: gl_internal_format = GL_R32UI; gl_pixel_format = GL_RED; break;
    //case tf_rg8i: gl_internal_format = GL_RG8I; gl_pixel_format = GL_RG; break;
    //case tf_rg8ui: gl_internal_format = GL_RG8UI; gl_pixel_format = GL_RG; break;
    //case tf_rg16i: gl_internal_format = GL_RG16I; gl_pixel_format = GL_RG; break;
    //case tf_rg16ui: gl_internal_format = GL_RG16UI; gl_pixel_format = GL_RG; break;
    //case tf_rg32i: gl_internal_format = GL_RG32I; gl_pixel_format = GL_RG; break;
    //case tf_rg32ui: gl_internal_format = GL_RG32UI; gl_pixel_format = GL_RG; break;
    //case tf_rgb8i: gl_internal_format = GL_RGB8I; gl_pixel_format = GL_RGB; break;
    //case tf_rgb8ui: gl_internal_format = GL_RGB8UI; gl_pixel_format = GL_RGB; break;
    //case tf_rgb16i: gl_internal_format = GL_RGB16I; gl_pixel_format = GL_RGB; break;
    //case tf_rgb16ui: gl_internal_format = GL_RGB16UI; gl_pixel_format = GL_RGB; break;
    //case tf_rgb32i: gl_internal_format = GL_RGB32I; gl_pixel_format = GL_RGB; break;
    //case tf_rgb32ui: gl_internal_format = GL_RGB32UI; gl_pixel_format = GL_RGB; break;
    //case tf_rgba8i: gl_internal_format = GL_RGBA8I; gl_pixel_format = GL_RGBA; break;
    //case tf_rgba8ui: gl_internal_format = GL_RGBA8UI; gl_pixel_format = GL_RGBA; break;
    //case tf_rgba16i: gl_internal_format = GL_RGBA16I; gl_pixel_format = GL_RGBA; break;
    //case tf_rgba16ui: gl_internal_format = GL_RGBA16UI; gl_pixel_format = GL_RGBA; break;
    //case tf_rgba32i: gl_internal_format = GL_RGBA32I; gl_pixel_format = GL_RGBA; break;
    //case tf_rgba32ui: gl_internal_format = GL_RGBA32UI; gl_pixel_format = GL_RGBA; break;
    case tf_depth_component16:
        gl_internal_format = GL_DEPTH_COMPONENT16;
        gl_pixel_format = GL_DEPTH_COMPONENT;
        break;
    case tf_depth_component24:
        gl_internal_format = GL_DEPTH_COMPONENT24;
        gl_pixel_format = GL_DEPTH_COMPONENT;
        break;
    case tf_depth_component32:
        gl_internal_format = GL_DEPTH_COMPONENT32;
        gl_pixel_format = GL_DEPTH_COMPONENT;
        break;
    //case tf_depth_component32f: gl_internal_format = GL_DEPTH_COMPONENT32F; gl_pixel_format = GL_DEPTH_COMPONENT; break;
    //case tf_depth24_stencil8: gl_internal_format = GL_DEPTH24_STENCIL8; gl_pixel_format = GL_DEPTH_STENCIL; break;
    //case tf_depth32f_stencil8: gl_internal_format = GL_DEPTH32F_STENCIL8; gl_pixel_format = GL_DEPTH_STENCIL; break;

    //case tf_compressed_red: gl_internal_format = GL_COMPRESSED_RED; gl_pixel_format = GL_RED; break;
    //case tf_compressed_rg: gl_internal_format = GL_COMPRESSED_RG; gl_pixel_format = GL_RG; break;
    case tf_compressed_rgb:
        gl_internal_format = GL_COMPRESSED_RGB;
        gl_pixel_format = GL_RGB;
        break;
    case tf_compressed_rgba:
        gl_internal_format = GL_COMPRESSED_RGBA;
        gl_pixel_format = GL_RGBA;
        break;
    //case tf_compressed_srgb: gl_internal_format = GL_COMPRESSED_SRGB; gl_pixel_format = GL_RGB; break;
    //case tf_compressed_srgb_alpha: gl_internal_format = GL_COMPRESSED_SRGB_ALPHA; gl_pixel_format = GL_RGBA; break;
    //case tf_compressed_red_rgtc1: gl_internal_format = GL_COMPRESSED_RED_RGTC1; gl_pixel_format = GL_RED; break;
    //case tf_compressed_signed_red_rgtc1: gl_internal_format = GL_COMPRESSED_SIGNED_RED_RGTC1; gl_pixel_format = GL_RED; break;
    //case tf_compressed_rg_rgtc2: gl_internal_format = GL_COMPRESSED_RG_RGTC2; gl_pixel_format = GL_RG; break;
    //case tf_compressed_signed_rg_rgtc2: gl_internal_format = GL_COMPRESSED_SIGNED_RG_RGTC2; gl_pixel_format = GL_RG; break;

    case tf_compressed_rgb_s3tc_dxt1:
        gl_internal_format = GL_COMPRESSED_RGB_S3TC_DXT1_EXT;
        gl_pixel_format = GL_RGB;
        break;
    case tf_compressed_rgba_s3tc_dxt1:
        gl_internal_format = GL_COMPRESSED_RGBA_S3TC_DXT1_EXT;
        gl_pixel_format = GL_RGBA;
        break;
    case tf_compressed_rgba_s3tc_dxt3:
        gl_internal_format = GL_COMPRESSED_RGBA_S3TC_DXT3_EXT;
        gl_pixel_format = GL_RGBA;
        break;
    case tf_compressed_rgba_s3tc_dxt5:
        gl_internal_format = GL_COMPRESSED_RGBA_S3TC_DXT5_EXT;
        gl_pixel_format = GL_RGBA;
        break;
    //case tf_compressed_srgb_s3tc_dxt1: gl_internal_format = GL_COMPRESSED_SRGB_S3TC_DXT1_EXT; gl_pixel_format = GL_RGB; break;
    //case tf_compressed_srgb_alpha_s3tc_dxt1: gl_internal_format = GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT; gl_pixel_format = GL_RGBA; break;
    //case tf_compressed_srgb_alpha_s3tc_dxt3: gl_internal_format = GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT; gl_pixel_format = GL_RGBA; break;
    //case tf_compressed_srgb_alpha_s3tc_dxt5: gl_internal_format = GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT; gl_pixel_format = GL_RGBA; break;

    default:
        throw Exception(string_format("Unsupported TextureFormat (%1)", format));
    }
}
Example #3
0
BodyDescription::BodyDescription(const PhysicsContext &pc, const std::string &resource_id, const XMLResourceDocument &resources)
: impl(new BodyDescription_Impl(pc.impl->get_owner()))
{
	/* example resource entry with all parameters:
	
	<body2d name="TestBody" type="static">
        <position x="0" y="0"/>
        <rotation angle="180"/>
        <velocity x="0" y="0" angular="0"/>
        <damping linear="0" angular="0"/>
		<parameters awake="true" can_sleep="true" bullet="false" active="true" />
    </body2d>

	*/
	XMLResourceNode resource = resources.get_resource(resource_id);
	if (resource.get_type() != "body2d" && resource.get_type() != "body2d_description")
		throw Exception(string_format("Resource '%1' is not of type 'body2d' or 'body2d_description'", resource_id));

	DomNode cur_node = resource.get_element().get_first_child();

	//Body type
	std::string body_type = resource.get_element().get_attribute("type","static");
	if(body_type == "kinematic") set_type(body_kinematic);
	else if(body_type == "dynamic") set_type(body_dynamic);
	else set_type(body_static);

	while(!cur_node.is_null())
	{
		if (!cur_node.is_element()) 
			continue;
		
		DomElement cur_element = cur_node.to_element();
		std::string tag_name = cur_element.get_tag_name();

		//<position x="0" y="0"/>
		if(tag_name == "position")
		{
			float pos_x = 0.0f;
			float pos_y = 0.0f;

			if(cur_element.has_attribute("x"))
			{
				pos_x = StringHelp::text_to_float(cur_element.get_attribute("x"));
			}

			if(cur_element.has_attribute("y"))
			{
				pos_y = StringHelp::text_to_float(cur_element.get_attribute("y"));
			}

			set_position(pos_x, pos_y);
		}

		//<rotation angle="180"/>
		else if(tag_name == "rotation")
		{
			Angle angle(0.0f, angle_degrees);

			if(cur_element.has_attribute("angle"))
			{
				angle = Angle(StringHelp::text_to_float(cur_element.get_attribute("angle")), angle_degrees);
			}

			set_angle(angle);
		}

		//<velocity x="0" y="0" angular="0"/>
		else if(tag_name == "velocity")
		{
			Vec2f velocity(0.0f, 0.0f);
			Angle angular_velocity(0.0f, angle_degrees);

			if(cur_element.has_attribute("x"))
			{
				velocity.x = StringHelp::text_to_float(cur_element.get_attribute("x"));
			}

			if(cur_element.has_attribute("y"))
			{
				velocity.y = StringHelp::text_to_float(cur_element.get_attribute("y"));
			}

			if(cur_element.has_attribute("angular"))
			{
				angular_velocity = Angle(StringHelp::text_to_float(cur_element.get_attribute("angular")), angle_degrees);
			}

			set_linear_velocity(velocity);
			set_angular_velocity(angular_velocity);
		}

		//<damping linear="0" angular="0"/>
		else if(tag_name == "damping")
		{
			float linear;
			float angular;

			if(cur_element.has_attribute("linear"))
			{
				linear = StringHelp::text_to_float(cur_element.get_attribute("linear"));
			}

			if(cur_element.has_attribute("angular"))
			{
				angular = StringHelp::text_to_float(cur_element.get_attribute("angular"));
			}

			set_linear_damping(linear);
			set_angular_damping(angular);
		}

		//<parameters awake="true" can_sleep="true" bullet="false" active="true" />
		else if(tag_name == "parameters")
		{
			bool value;
		
			if(cur_element.has_attribute("awake"))
			{
				value = true;
				value = StringHelp::text_to_bool(cur_element.get_attribute("awake"));
				set_awake(value);
			}
			if(cur_element.has_attribute("active"))
			{
				value = true;
				value = StringHelp::text_to_bool(cur_element.get_attribute("active"));
				set_active(value);
			}
			if(cur_element.has_attribute("bullet"))
			{
				value = false;
				value = StringHelp::text_to_bool(cur_element.get_attribute("bullet"));
				set_as_bullet(value);
			}
			if(cur_element.has_attribute("can_sleep"))
			{
				value = true;
				value = StringHelp::text_to_bool(cur_element.get_attribute("can_sleep"));
				allow_sleep(value);
			}
		}

		cur_node = cur_node.get_next_sibling();
	}
}
Example #4
0
void CBasicBlock::Compile()
{
#ifndef AOT_USE_CACHE

	Framework::CMemStream stream;
	{
		static __declspec(thread) CMipsJitter* jitter = NULL;
		if(jitter == NULL)
		{
			Jitter::CCodeGen* codeGen = Jitter::CreateCodeGen();
			jitter = new CMipsJitter(codeGen);

			for(unsigned int i = 0; i < 4; i++)
			{
				jitter->SetVariableAsConstant(
					offsetof(CMIPS, m_State.nGPR[CMIPS::R0].nV[i]),
					0
					);
			}
		}

		jitter->SetStream(&stream);
		jitter->Begin();
		CompileRange(jitter);
//		codeGen.DumpVariables(0);
//		codeGen.EndQuota();
		jitter->End();
	}

	m_function = CMemoryFunction(stream.GetBuffer(), stream.GetSize());
	
#ifdef VTUNE_ENABLED
	if(iJIT_IsProfilingActive() == iJIT_SAMPLING_ON)
	{
		iJIT_Method_Load jmethod = {};
		jmethod.method_id = iJIT_GetNewMethodID();
		jmethod.class_file_name = "";
		jmethod.source_file_name = __FILE__;

		jmethod.method_load_address = m_function.GetCode();
		jmethod.method_size = m_function.GetSize();
		jmethod.line_number_size = 0;

		auto functionName = string_format("BasicBlock_0x%0.8X_0x%0.8X", m_begin, m_end);

		jmethod.method_name = const_cast<char*>(functionName.c_str());
		iJIT_NotifyEvent(iJVM_EVENT_TYPE_METHOD_LOAD_FINISHED, reinterpret_cast<void*>(&jmethod));
	}
#endif

#endif

#ifdef AOT_ENABLED

	size_t blockSize = ((m_end - m_begin) / 4) + 1;
	auto blockData = new uint32[blockSize];

	for(uint32 i = 0; i < blockSize; i++)
	{
		blockData[i] = m_context.m_pMemoryMap->GetWord(m_begin + (i * 4));
	}

	uint32 blockChecksum = crc32(0, reinterpret_cast<Bytef*>(blockData), blockSize * 4);

#endif

#ifdef AOT_USE_CACHE

	AOT_BLOCK* blocksBegin = &_aot_firstBlock;
	AOT_BLOCK* blocksEnd = blocksBegin + _aot_blockCount;

	AOT_BLOCK blockRef = { blockChecksum, m_begin, m_end, nullptr };

	static const auto blockComparer = 
		[] (const AOT_BLOCK& item1, const AOT_BLOCK& item2)
		{
			return item1.key < item2.key;
		};

//	assert(std::is_sorted(blocksBegin, blocksEnd, blockComparer));

	bool blockExists = std::binary_search(blocksBegin, blocksEnd, blockRef, blockComparer);
	auto blockIterator = std::lower_bound(blocksBegin, blocksEnd, blockRef, blockComparer);
	
	assert(blockExists);
	assert(blockIterator != blocksEnd);
	assert(blockIterator->key.crc == blockChecksum);
	assert(blockIterator->key.begin == m_begin);
	assert(blockIterator->key.end == m_end);

	m_function = reinterpret_cast<void (*)(void*)>(blockIterator->fct);

#endif

#ifdef AOT_BUILD_CACHE
	{
		std::lock_guard<std::mutex> lock(m_aotBlockOutputStreamMutex);

		m_aotBlockOutputStream->Write32(blockChecksum);
		m_aotBlockOutputStream->Write32(m_begin);
		m_aotBlockOutputStream->Write32(m_end);
		m_aotBlockOutputStream->Write(blockData, blockSize * 4);
	}
#endif
}
Example #5
0
Font &CSSResourceCache::get_font(Canvas &canvas, const CSSComputedValues &properties)
{
	const CSSComputedFont &font_values = properties.get_font();
	int font_size = used_to_actual(font_values.font_size.length.value);
	std::string font_name;
	for (size_t i = 0; i < font_values.font_family.names.size(); i++)
	{
		bool matched = false;
		std::string search_name;
		switch (font_values.font_family.names[i].type)
		{
		case CSSValueFontFamilyName::type_family_name:
			search_name = StringHelp::text_to_lower(font_values.font_family.names[i].name);
			if (font_families.find(search_name) != font_families.end())
			{
				font_name = font_values.font_family.names[i].name;
				matched = true;
			}
			break;
		default:
		case CSSValueFontFamilyName::type_serif:
		case CSSValueFontFamilyName::type_cursive:
		case CSSValueFontFamilyName::type_fantasy:
			font_name = "Times New Roman"; // Ugliest font on the planet.
			matched = true;
			break;
		case CSSValueFontFamilyName::type_sans_serif:
			font_name = "Arial";
			matched = true;
			break;
		case CSSValueFontFamilyName::type_monospace:
			font_name = "Courier New";
			matched = true;
			break;
		}
		if (matched)
			break;
	}
	if (font_name.empty())
		font_name = "Times New Roman";

	int font_weight = 400;
	switch (font_values.font_weight.type)
	{
	case CSSValueFontWeight::type_100: font_weight = 100; break;
	case CSSValueFontWeight::type_200: font_weight = 200; break;
	case CSSValueFontWeight::type_300: font_weight = 300; break;
	case CSSValueFontWeight::type_400: font_weight = 400; break;
	case CSSValueFontWeight::type_500: font_weight = 500; break;
	case CSSValueFontWeight::type_600: font_weight = 600; break;
	case CSSValueFontWeight::type_700: font_weight = 700; break;
	case CSSValueFontWeight::type_800: font_weight = 800; break;
	case CSSValueFontWeight::type_900: font_weight = 900; break;
	case CSSValueFontWeight::type_normal: font_weight = 400; break;
	case CSSValueFontWeight::type_bold: font_weight = 700; break;
	case CSSValueFontWeight::type_bolder: font_weight = 900; break;
	case CSSValueFontWeight::type_lighter: font_weight = 300; break;
	}
	bool italic = false;
	switch (font_values.font_style.type)
	{
	case CSSValueFontStyle::type_normal: italic = false; break;
	case CSSValueFontStyle::type_italic: italic = true; break;
	case CSSValueFontStyle::type_oblique: italic = true; break;
	}
	std::string font_cache_name = string_format("%1+++%2+%3", font_name, font_size, font_weight);
	if (italic) font_cache_name += "i";
	std::map<std::string, Font>::iterator it = font_cache.find(font_cache_name);
	if (it == font_cache.end())
	{
		FontDescription font_desc;
		font_desc.set_typeface_name(font_name);
		font_desc.set_height(-font_size);
		font_desc.set_weight(font_weight);
		font_desc.set_italic(italic);
		font_cache[font_cache_name] = Font(canvas, font_desc);
		return font_cache[font_cache_name];
	}
	else
	{
		return it->second;
	}
}
Example #6
0
bool game::dump_stats( const std::string& what, dump_mode mode, const std::vector<std::string> &opts )
{
    try {
        load_core_data();
    } catch( const std::exception &err ) {
        std::cerr << "Error loading data from json: " << err.what() << std::endl;
        return false;
    }
    DynamicDataLoader::get_instance().finalize_loaded_data();

    std::vector<std::string> header;
    std::vector<std::vector<std::string>> rows;

    int scol = 0; // sorting column

    std::map<std::string, standard_npc> test_npcs;
    test_npcs[ "S1" ] = standard_npc( "S1", { "gloves_survivor", "mask_lsurvivor" }, 4, 8, 10, 8, 10 /* DEX 10, PER 10 */ );
    test_npcs[ "S2" ] = standard_npc( "S2", { "gloves_fingerless", "sunglasses" }, 4, 8, 8, 8, 10 /* PER 10 */ );
    test_npcs[ "S3" ] = standard_npc( "S3", { "gloves_plate", "helmet_plate" },  4, 10, 8, 8, 8 /* STAT 10 */ );
    test_npcs[ "S4" ] = standard_npc( "S4", {}, 0, 8, 10, 8, 10 /* DEX 10, PER 10 */ );
    test_npcs[ "S5" ] = standard_npc( "S5", {}, 4, 8, 10, 8, 10 /* DEX 10, PER 10 */ );
    test_npcs[ "S6" ] = standard_npc( "S6", { "gloves_hsurvivor", "mask_hsurvivor" }, 4, 8, 10, 8, 10 /* DEX 10, PER 10 */ );

    std::map<std::string, item> test_items;
    test_items[ "G1" ] = item( "glock_19" ).ammo_set( "9mm" );
    test_items[ "G2" ] = item( "hk_mp5" ).ammo_set( "9mm" );
    test_items[ "G3" ] = item( "ar15" ).ammo_set( "223" );
    test_items[ "G4" ] = item( "remington_700" ).ammo_set( "270" );
    test_items[ "G4" ].emplace_back( "rifle_scope" );

    if( what == "AMMO" ) {
        header = {
            "Name", "Ammo", "Volume", "Weight", "Stack",
            "Range", "Dispersion", "Recoil", "Damage", "Pierce"
        };
        auto dump = [&rows]( const item& obj ) {
            std::vector<std::string> r;
            r.push_back( obj.tname( 1, false ) );
            r.push_back( obj.type->ammo->type.str() );
            r.push_back( to_string( obj.volume() / units::legacy_volume_factor ) );
            r.push_back( to_string( obj.weight() ) );
            r.push_back( to_string( obj.type->stack_size ) );
            r.push_back( to_string( obj.type->ammo->range ) );
            r.push_back( to_string( obj.type->ammo->dispersion ) );
            r.push_back( to_string( obj.type->ammo->recoil ) );
            r.push_back( to_string( obj.type->ammo->damage ) );
            r.push_back( to_string( obj.type->ammo->pierce ) );
            rows.push_back( r );
        };
        for( auto& e : item_controller->get_all_itypes() ) {
            if( e.second->ammo ) {
                dump( item( e.first, calendar::turn, item::solitary_tag {} ) );
            }
        }

    } else if( what == "ARMOR" ) {
        header = {
            "Name", "Encumber (fit)", "Warmth", "Weight", "Storage", "Coverage", "Bash", "Cut", "Acid", "Fire"
        };
        auto dump = [&rows]( const item& obj ) {
            std::vector<std::string> r;
            r.push_back( obj.tname( 1, false ) );
            r.push_back( to_string( obj.get_encumber() ) );
            r.push_back( to_string( obj.get_warmth() ) );
            r.push_back( to_string( obj.weight() ) );
            r.push_back( to_string( obj.get_storage() / units::legacy_volume_factor ) );
            r.push_back( to_string( obj.get_coverage() ) );
            r.push_back( to_string( obj.bash_resist() ) );
            r.push_back( to_string( obj.cut_resist() ) );
            r.push_back( to_string( obj.acid_resist() ) );
            r.push_back( to_string( obj.fire_resist() ) );
            rows.push_back( r );
        };

        body_part bp = opts.empty() ? num_bp : get_body_part_token( opts.front() );

        for( auto& e : item_controller->get_all_itypes() ) {
            if( e.second->armor ) {
                item obj( e.first );
                if( bp == num_bp || obj.covers( bp ) ) {
                    if( obj.has_flag( "VARSIZE" ) ) {
                        obj.item_tags.insert( "FIT" );
                    }
                    dump( obj );
                }
            }
        }

    } else if( what == "EDIBLE" ) {
        header = {
            "Name", "Volume", "Weight", "Stack", "Calories", "Quench", "Healthy"
        };
        for( const auto& v : vitamin::all() ) {
             header.push_back( v.second.name() );
        }
        auto dump = [&rows,&test_npcs]( const item& obj ) {
            std::vector<std::string> r;
            r.push_back( obj.tname( false ) );
            r.push_back( to_string( obj.volume() / units::legacy_volume_factor ) );
            r.push_back( to_string( obj.weight() ) );
            r.push_back( to_string( obj.type->stack_size ) );
            r.push_back( to_string( obj.type->comestible->get_calories() ) );
            r.push_back( to_string( obj.type->comestible->quench ) );
            r.push_back( to_string( obj.type->comestible->healthy ) );
            auto vits = g->u.vitamins_from( obj );
            for( const auto& v : vitamin::all() ) {
                 r.push_back( to_string( vits[ v.first ] ) );
            }
            rows.push_back( r );
        };
        for( auto& e : item_controller->get_all_itypes() ) {
            if( e.second->comestible &&
                ( e.second->comestible->comesttype == "FOOD" ||
                  e.second->comestible->comesttype == "DRINK" ) ) {

                item food( e.first, calendar::turn, item::solitary_tag {} );
                if( g->u.can_eat( food, false, true ) == EDIBLE ) {
                    dump( food );
                }
            }
        }

    } else if( what == "GUN" ) {
        header = {
            "Name", "Ammo", "Volume", "Weight", "Capacity",
            "Range", "Dispersion", "Effective recoil", "Damage", "Pierce",
            "Aim time", "Effective range", "Snapshot range", "Max range"
        };

        std::set<std::string> locations;
        for( const auto& e : item_controller->get_all_itypes() ) {
            if( e.second->gun ) {
                std::transform( e.second->gun->valid_mod_locations.begin(),
                                e.second->gun->valid_mod_locations.end(),
                                std::inserter( locations, locations.begin() ),
                                []( const std::pair<std::string, int>& e ) { return e.first; } );
            }
        }
        for( const auto &e : locations ) {
            header.push_back( e );
        }

        auto dump = [&rows,&locations]( const standard_npc &who, const item& obj ) {
            std::vector<std::string> r;
            r.push_back( obj.tname( 1, false ) );
            r.push_back( obj.ammo_type() ? obj.ammo_type().str() : "" );
            r.push_back( to_string( obj.volume() / units::legacy_volume_factor ) );
            r.push_back( to_string( obj.weight() ) );
            r.push_back( to_string( obj.ammo_capacity() ) );
            r.push_back( to_string( obj.gun_range() ) );
            r.push_back( to_string( obj.gun_dispersion() ) );
            r.push_back( to_string( obj.gun_recoil( who ) ) );
            r.push_back( to_string( obj.gun_damage() ) );
            r.push_back( to_string( obj.gun_pierce() ) );

            r.push_back( to_string( who.gun_engagement_moves( obj ) ) );

            r.push_back( string_format( "%.1f", who.gun_engagement_range( obj, player::engagement::effective ) ) );
            r.push_back( string_format( "%.1f", who.gun_engagement_range( obj, player::engagement::snapshot ) ) );
            r.push_back( string_format( "%.1f", who.gun_engagement_range( obj, player::engagement::maximum ) ) );

            for( const auto &e : locations ) {
                r.push_back( to_string( obj.type->gun->valid_mod_locations[ e ] ) );
            }
            rows.push_back( r );
        };
        for( const auto& e : item_controller->get_all_itypes() ) {
            if( e.second->gun ) {
                item gun( e.first );
                if( !gun.magazine_integral() ) {
                    gun.emplace_back( gun.magazine_default() );
                }
                gun.ammo_set( default_ammo( gun.ammo_type() ), gun.ammo_capacity() );

                dump( test_npcs[ "S1" ], gun );

                if( gun.type->gun->barrel_length > 0 ) {
                    gun.emplace_back( "barrel_small" );
                    dump( test_npcs[ "S1" ], gun );
                }
            }
        }

    } else if( what == "VEHICLE" ) {
        header = {
            "Name", "Weight (empty)", "Weight (fueled)",
            "Max velocity (mph)", "Safe velocity (mph)", "Acceleration (mph/turn)",
            "Mass coeff %", "Aerodynamics coeff %", "Friction coeff %",
            "Traction coeff % (grass)"
        };
        auto dump = [&rows]( const vproto_id& obj ) {
            auto veh_empty = vehicle( obj, 0, 0 );
            auto veh_fueled = vehicle( obj, 100, 0 );

            std::vector<std::string> r;
            r.push_back( veh_empty.name );
            r.push_back( to_string( veh_empty.total_mass() ) );
            r.push_back( to_string( veh_fueled.total_mass() ) );
            r.push_back( to_string( veh_fueled.max_velocity() / 100 ) );
            r.push_back( to_string( veh_fueled.safe_velocity() / 100 ) );
            r.push_back( to_string( veh_fueled.acceleration() / 100 ) );
            r.push_back( to_string( (int)( 100 * veh_fueled.k_mass() ) ) );
            r.push_back( to_string( (int)( 100 * veh_fueled.k_aerodynamics() ) ) );
            r.push_back( to_string( (int)( 100 * veh_fueled.k_friction() ) ) );
            r.push_back( to_string( (int)( 100 * veh_fueled.k_traction( veh_fueled.wheel_area( false ) / 2.0f ) ) ) );
            rows.push_back( r );
        };
        for( auto& e : vehicle_prototype::get_all() ) {
            dump( e );
        }

    } else if( what == "VPART" ) {
        header = {
            "Name", "Location", "Weight", "Size"
        };
        auto dump = [&rows]( const vpart_info *obj ) {
            std::vector<std::string> r;
            r.push_back( obj->name() );
            r.push_back( obj->location );
            r.push_back( to_string( int( ceil( item( obj->item ).weight() / 1000.0 ) ) ) );
            r.push_back( to_string( obj->size / units::legacy_volume_factor ) );
            rows.push_back( r );
        };
        for( const auto e : vpart_info::get_all() ) {
            dump( e );
        }

    } else if( what == "AIMING" ) {
        scol = -1; // unsorted output so graph columns have predictable ordering

        const int cycles = 1400;

        header = { "Name" };
        for( int i = 0; i <= cycles; ++i ) {
            header.push_back( to_string( i ) );
        }

        auto dump = [&rows]( const standard_npc &who, const item &gun) {
            std::vector<std::string> r( 1, string_format( "%s %s", who.get_name().c_str(), gun.tname().c_str() ) );
            double penalty = MIN_RECOIL;
            for( int i = 0; i <= cycles; ++i ) {
                penalty -= who.aim_per_move( gun, penalty );
                r.push_back( string_format( "%.2f", who.gun_current_range( gun, penalty ) ) );
            }
            rows.push_back( r );
        };

        if( opts.empty() ) {
            dump( test_npcs[ "S1" ], test_items[ "G1" ] );
            dump( test_npcs[ "S1" ], test_items[ "G2" ] );
            dump( test_npcs[ "S1" ], test_items[ "G3" ] );
            dump( test_npcs[ "S1" ], test_items[ "G4" ] );

        } else {
            for( const auto &str : opts ) {
                auto idx = str.find( ':' );
                if( idx == std::string::npos ) {
                    std::cerr << "cannot parse test case: " << str << std::endl;
                    return false;
                }
                auto test = std::make_pair( test_npcs.find( str.substr( 0, idx ) ),
                                            test_items.find( str.substr( idx + 1 ) ) );

                if( test.first == test_npcs.end() || test.second == test_items.end() ) {
                    std::cerr << "invalid test case: " << str << std::endl;
                    return false;
                }

                dump( test.first->second, test.second->second );
            }
        }

    } else if( what == "EXPLOSIVE" ) {
        header = {
            // @todo Should display more useful data: shrapnel damage, safe range
            "Name", "Power", "Power at 5 tiles", "Power halves at", "Shrapnel count", "Shrapnel mass"
        };

        auto dump = [&rows]( const std::string &name, const explosion_data &ex ) {
            std::vector<std::string> r;
            r.push_back( name );
            r.push_back( to_string( ex.power ) );
            r.push_back( string_format( "%.1f", ex.power_at_range( 5.0f ) ) );
            r.push_back( string_format( "%.1f", ex.expected_range( 0.5f ) ) );
            r.push_back( to_string( ex.shrapnel.count ) );
            r.push_back( to_string( ex.shrapnel.mass ) );
            rows.push_back( r );
        };
        for( const auto& e : item_controller->get_all_itypes() ) {
            const auto &itt = *e.second;
            const auto use = itt.get_use( "explosion" );
            if( use != nullptr && use->get_actor_ptr() != nullptr ) {
                const auto actor = dynamic_cast<const explosion_iuse *>( use->get_actor_ptr() );
                if( actor != nullptr ) {
                    dump( itt.nname( 1 ), actor->explosion );
                }
            }

            auto c_ex = dynamic_cast<const explosion_iuse *>( itt.countdown_action.get_actor_ptr() );
            if( c_ex != nullptr ) {
                dump( itt.nname( 1 ), c_ex->explosion );
            }
        }

    } else {
        std::cerr << "unknown argument: " << what << std::endl;
        return false;
    }

    rows.erase( std::remove_if( rows.begin(), rows.end(), []( const std::vector<std::string>& e ) {
        return e.empty();
    } ), rows.end() );

    if( scol >= 0 ) {
        std::sort( rows.begin(), rows.end(), [&scol]( const std::vector<std::string>& lhs, const std::vector<std::string>& rhs ) {
            return lhs[ scol ] < rhs[ scol ];
        } );
    }

    rows.erase( std::unique( rows.begin(), rows.end() ), rows.end() );

    switch( mode ) {
        case dump_mode::TSV:
            rows.insert( rows.begin(), header );
            for( const auto& r : rows ) {
                std::copy( r.begin(), r.end() - 1, std::ostream_iterator<std::string>( std::cout, "\t" ) );
                std::cout << r.back() << "\n";
            }
            break;

        case dump_mode::HTML:
            std::cout << "<table>";

            std::cout << "<thead>";
            std::cout << "<tr>";
            for( const auto& col : header ) {
                std::cout << "<th>" << col << "</th>";
            }
            std::cout << "</tr>";
            std::cout << "</thead>";

            std::cout << "<tdata>";
            for( const auto& r : rows ) {
                std::cout << "<tr>";
                for( const auto& col : r ) {
                    std::cout << "<td>" << col << "</td>";
                }
                std::cout << "</tr>";
            }
            std::cout << "</tdata>";

            std::cout << "</table>";
            break;
    }

    return true;
}
Example #7
0
/*
 * Set skill on any player object; player character or NPC
 */
void game::wishskill(player * p) {

      const int skoffset = 1;
      uimenu skmenu;
      skmenu.text = "Select a skill to modify";
      skmenu.return_invalid = true;
      skmenu.addentry(0, true, '1', "Set all skills to...");
      int *origskills = new int[Skill::skills.size()] ;

      for (std::vector<Skill*>::iterator aSkill = Skill::skills.begin();
           aSkill != Skill::skills.end(); ++aSkill) {
        int skill_id = (*aSkill)->id();
        skmenu.addentry( skill_id + skoffset, true, -2, "@ %d: %s  ",
                         (int)p->skillLevel(*aSkill), (*aSkill)->ident().c_str() );
        origskills[skill_id] = (int)p->skillLevel(*aSkill);
      }
      do {
        skmenu.query();
        int skill_id = -1;
        int skset = -1;
        int sksel = skmenu.selected - skoffset;
        if ( skmenu.ret == -1 && ( skmenu.keypress == KEY_LEFT || skmenu.keypress == KEY_RIGHT ) ) {
          if ( sksel >= 0 && sksel < Skill::skills.size() ) {
            skill_id = sksel;
            skset = (int)p->skillLevel( Skill::skills[skill_id]) +
                ( skmenu.keypress == KEY_LEFT ? -1 : 1 );
          }
          skmenu.ret = -2;
        } else if ( skmenu.selected == skmenu.ret &&  sksel >= 0 && sksel < Skill::skills.size() ) {
          skill_id = sksel;
          uimenu sksetmenu;
          sksetmenu.w_x = skmenu.w_x + skmenu.w_width + 1;
          sksetmenu.w_y = skmenu.w_y + 2;
          sksetmenu.w_height = skmenu.w_height - 4;
          sksetmenu.return_invalid = true;
          sksetmenu.settext( "Set '%s' to..", Skill::skills[skill_id]->ident().c_str() );
          int skcur = (int)p->skillLevel(Skill::skills[skill_id]);
          sksetmenu.selected = skcur;
          for ( int i = 0; i < 21; i++ ) {
              sksetmenu.addentry( i, true, i + 48, "%d%s", i, (skcur == i ? " (current)" : "") );
          }
          sksetmenu.query();
          skset = sksetmenu.ret;
        }

        if ( skset != UIMENU_INVALID && skset != -1 && skill_id != -1 ) {
          p->skillLevel( Skill::skills[skill_id] ).level(skset);
          skmenu.textformatted[0] = string_format("%s set to %d             ",
              Skill::skills[skill_id]->ident().c_str(),
              (int)p->skillLevel(Skill::skills[skill_id])).substr(0,skmenu.w_width - 4);
          skmenu.entries[skill_id + skoffset].txt = string_format("@ %d: %s  ",
              (int)p->skillLevel( Skill::skills[skill_id]), Skill::skills[skill_id]->ident().c_str() );
          skmenu.entries[skill_id + skoffset].text_color =
              ( (int)p->skillLevel(Skill::skills[skill_id]) == origskills[skill_id] ?
                skmenu.text_color : c_yellow );
        } else if ( skmenu.ret == 0 && sksel == -1 ) {
          int ret = menu(true, "Set all skills...",
                         "+3","+1","-1","-3","To 0","To 5","To 10","(Reset changes)",NULL);
          if ( ret > 0 ) {
              int skmod = 0;
              int skset = -1;
              if (ret < 5 ) {
                skmod=( ret < 3 ? ( ret == 1 ? 3 : 1 ) :
                    ( ret == 3 ? -1 : -3 )
                );
              } else if ( ret < 8 ) {
                skset=( ( ret - 5 ) * 5 );
              }
              for (int skill_id = 0; skill_id < Skill::skills.size(); skill_id++ ) {
                int changeto = ( skmod != 0 ? p->skillLevel( Skill::skills[skill_id] ) + skmod :
                                 ( skset != -1 ? skset : origskills[skill_id] ) );
                p->skillLevel( Skill::skills[skill_id] ).level( changeto );
                skmenu.entries[skill_id + skoffset].txt =
                    string_format("@ %d: %s  ", (int)p->skillLevel(Skill::skills[skill_id]),
                                  Skill::skills[skill_id]->ident().c_str() );
                skmenu.entries[skill_id + skoffset].text_color =
                    ( (int)p->skillLevel(Skill::skills[skill_id]) == origskills[skill_id] ?
                      skmenu.text_color : c_yellow );
              }
          }
        }
      } while ( skmenu.ret != -1 && ( skmenu.keypress != 'q' && skmenu.keypress != ' ' &&
                                      skmenu.keypress != KEY_ESCAPE ) );
      delete[] origskills;
}
int game::inv_for_tools_powered_by( const ammotype &battery_id, const std::string &title )
{
    return inv_for_filter( title, [ &battery_id ]( const item & it ) {
        return it.is_tool() && it.ammo_type() == battery_id;
    }, string_format( _( "You don't have %s-powered tools." ), ammo_name( battery_id ).c_str() ) );
}
Example #9
0
void player::power_mutations()
{
    std::vector <std::string> passive;
    std::vector <std::string> active;
    for( auto &mut : my_mutations ) {
        if (!mutation_branch::get( mut.first ).activated) {
            passive.push_back(mut.first);
        } else {
            active.push_back(mut.first);
        }
        // New mutations are initialized with no key at all, so we have to do this here.
        if( mut.second.key == ' ' ) {
            for( const auto &letter : inv_chars ) {
                if( trait_by_invlet( letter ).empty() ) {
                    mut.second.key = letter;
                    break;
                }
            }
        }
    }

    // maximal number of rows in both columns
    const int mutations_count = std::max(passive.size(), active.size());

    int TITLE_HEIGHT = 2;
    int DESCRIPTION_HEIGHT = 5;

    // Main window
    /** Total required height is:
    * top frame line:                                         + 1
    * height of title window:                                 + TITLE_HEIGHT
    * line after the title:                                   + 1
    * line with active/passive mutation captions:               + 1
    * height of the biggest list of active/passive mutations:   + mutations_count
    * line before mutation description:                         + 1
    * height of description window:                           + DESCRIPTION_HEIGHT
    * bottom frame line:                                      + 1
    * TOTAL: TITLE_HEIGHT + mutations_count + DESCRIPTION_HEIGHT + 5
    */
    int HEIGHT = std::min(TERMY, std::max(FULL_SCREEN_HEIGHT,
                                          TITLE_HEIGHT + mutations_count + DESCRIPTION_HEIGHT + 5));
    int WIDTH = FULL_SCREEN_WIDTH + (TERMX - FULL_SCREEN_WIDTH) / 2;
    int START_X = (TERMX - WIDTH) / 2;
    int START_Y = (TERMY - HEIGHT) / 2;
    WINDOW *wBio = newwin(HEIGHT, WIDTH, START_Y, START_X);

    // Description window @ the bottom of the bio window
    int DESCRIPTION_START_Y = START_Y + HEIGHT - DESCRIPTION_HEIGHT - 1;
    int DESCRIPTION_LINE_Y = DESCRIPTION_START_Y - START_Y - 1;
    WINDOW *w_description = newwin(DESCRIPTION_HEIGHT, WIDTH - 2,
                                   DESCRIPTION_START_Y, START_X + 1);

    // Title window
    int TITLE_START_Y = START_Y + 1;
    int HEADER_LINE_Y = TITLE_HEIGHT + 1; // + lines with text in titlebar, local
    WINDOW *w_title = newwin(TITLE_HEIGHT, WIDTH - 2, TITLE_START_Y, START_X + 1);

    int scroll_position = 0;
    int second_column = 32 + (TERMX - FULL_SCREEN_WIDTH) /
                        4; // X-coordinate of the list of active mutations

    input_context ctxt("MUTATIONS");
    ctxt.register_updown();
    ctxt.register_action("ANY_INPUT");
    ctxt.register_action("TOGGLE_EXAMINE");
    ctxt.register_action("REASSIGN");
    ctxt.register_action("HELP_KEYBINDINGS");

    bool redraw = true;
    std::string menu_mode = "activating";

    while(true) {
        // offset for display: mutation with index i is drawn at y=list_start_y+i
        // drawing the mutation starts with mutation[scroll_position]
        const int list_start_y = HEADER_LINE_Y + 2 - scroll_position;
        int max_scroll_position = HEADER_LINE_Y + 2 + mutations_count -
                                  ((menu_mode == "examining") ? DESCRIPTION_LINE_Y : (HEIGHT - 1));
        if(redraw) {
            redraw = false;

            werase(wBio);
            draw_border(wBio);
            // Draw line under title
            mvwhline(wBio, HEADER_LINE_Y, 1, LINE_OXOX, WIDTH - 2);
            // Draw symbols to connect additional lines to border
            mvwputch(wBio, HEADER_LINE_Y, 0, BORDER_COLOR, LINE_XXXO); // |-
            mvwputch(wBio, HEADER_LINE_Y, WIDTH - 1, BORDER_COLOR, LINE_XOXX); // -|

            // Captions
            mvwprintz(wBio, HEADER_LINE_Y + 1, 2, c_ltblue, _("Passive:"));
            mvwprintz(wBio, HEADER_LINE_Y + 1, second_column, c_ltblue, _("Active:"));

            draw_exam_window(wBio, DESCRIPTION_LINE_Y, menu_mode == "examining");
            nc_color type;
            if (passive.empty()) {
                mvwprintz(wBio, list_start_y, 2, c_ltgray, _("None"));
            } else {
                for (size_t i = scroll_position; i < passive.size(); i++) {
                    const auto &md = mutation_branch::get( passive[i] );
                    const auto &td = my_mutations[passive[i]];
                    if (list_start_y + static_cast<int>(i) ==
                        (menu_mode == "examining" ? DESCRIPTION_LINE_Y : HEIGHT - 1)) {
                        break;
                    }
                    type = c_cyan;
                    mvwprintz(wBio, list_start_y + i, 2, type, "%c %s", td.key, md.name.c_str());
                }
            }

            if (active.empty()) {
                mvwprintz(wBio, list_start_y, second_column, c_ltgray, _("None"));
            } else {
                for (size_t i = scroll_position; i < active.size(); i++) {
                    const auto &md = mutation_branch::get( active[i] );
                    const auto &td = my_mutations[active[i]];
                    if (list_start_y + static_cast<int>(i) ==
                        (menu_mode == "examining" ? DESCRIPTION_LINE_Y : HEIGHT - 1)) {
                        break;
                    }
                    if (!td.powered) {
                        type = c_red;
                    }else if (td.powered) {
                        type = c_ltgreen;
                    } else {
                        type = c_ltred;
                    }
                    // TODO: track resource(s) used and specify
                    mvwputch( wBio, list_start_y + i, second_column, type, td.key );
                    std::stringstream mut_desc;
                    mut_desc << md.name;
                    if ( md.cost > 0 && md.cooldown > 0 ) {
                        mut_desc << string_format( _(" - %d RU / %d turns"),
                                      md.cost, md.cooldown );
                    } else if ( md.cost > 0 ) {
                        mut_desc << string_format( _(" - %d RU"), md.cost );
                    } else if ( md.cooldown > 0 ) {
                        mut_desc << string_format( _(" - %d turns"), md.cooldown );
                    }
                    if ( td.powered ) {
                        mut_desc << _(" - Active");
                    }
                    mvwprintz( wBio, list_start_y + i, second_column + 2, type,
                               mut_desc.str().c_str() );
                }
            }

            // Scrollbar
            if(scroll_position > 0) {
                mvwputch(wBio, HEADER_LINE_Y + 2, 0, c_ltgreen, '^');
            }
            if(scroll_position < max_scroll_position && max_scroll_position > 0) {
                mvwputch(wBio, (menu_mode == "examining" ? DESCRIPTION_LINE_Y : HEIGHT - 1) - 1,
                         0, c_ltgreen, 'v');
            }
        }
        wrefresh(wBio);
        show_mutations_titlebar(w_title, this, menu_mode);
        const std::string action = ctxt.handle_input();
        const long ch = ctxt.get_raw_input().get_first_input();
        if (menu_mode == "reassigning") {
            menu_mode = "activating";
            const auto mut_id = trait_by_invlet( ch );
            if( mut_id.empty() ) {
                // Selected an non-existing mutation (or escape, or ...)
                continue;
            }
            redraw = true;
            const char newch = popup_getkey(_("%s; enter new letter."),
                                            mutation_branch::get_name( mut_id ).c_str());
            wrefresh(wBio);
            if(newch == ch || newch == ' ' || newch == KEY_ESCAPE) {
                continue;
            }
            const auto other_mut_id = trait_by_invlet( newch );
            // if there is already a mutation with the new key, the key
            // is considered valid.
            if( other_mut_id.empty() && inv_chars.find(newch) == std::string::npos ) {
                // TODO separate list of letters for mutations
                popup(_("%c is not a valid inventory letter."), newch);
                continue;
            }
            if( !other_mut_id.empty() ) {
                std::swap(my_mutations[mut_id].key, my_mutations[other_mut_id].key);
            } else {
                my_mutations[mut_id].key = newch;
            }
            // TODO: show a message like when reassigning a key to an item?
        } else if (action == "DOWN") {
            if(scroll_position < max_scroll_position) {
                scroll_position++;
                redraw = true;
            }
        } else if (action == "UP") {
            if(scroll_position > 0) {
                scroll_position--;
                redraw = true;
            }
        } else if (action == "REASSIGN") {
            menu_mode = "reassigning";
        } else if (action == "TOGGLE_EXAMINE") { // switches between activation and examination
            menu_mode = menu_mode == "activating" ? "examining" : "activating";
            werase(w_description);
            draw_exam_window(wBio, DESCRIPTION_LINE_Y, false);
            redraw = true;
        }else if (action == "HELP_KEYBINDINGS") {
            redraw = true;
        } else {
            const auto mut_id = trait_by_invlet( ch );
            if( mut_id.empty() ) {
                // entered a key that is not mapped to any mutation,
                // -> leave screen
                break;
            }
            const auto &mut_data = mutation_branch::get( mut_id );
            if (menu_mode == "activating") {
                if (mut_data.activated) {
                    if (my_mutations[mut_id].powered) {
                        add_msg(m_neutral, _("You stop using your %s."), mut_data.name.c_str());

                        deactivate_mutation( mut_id );
                        delwin(w_title);
                        delwin(w_description);
                        delwin(wBio);
                        // Action done, leave screen
                        break;
                    } else if( (!mut_data.hunger || hunger <= 400) &&
                               (!mut_data.thirst || thirst <= 400) &&
                               (!mut_data.fatigue || fatigue <= 400) ) {

                        // this will clear the mutations menu for targeting purposes
                        werase(wBio);
                        wrefresh(wBio);
                        delwin(w_title);
                        delwin(w_description);
                        delwin(wBio);
                        g->draw();
                        add_msg( m_neutral, _("You activate your %s."), mut_data.name.c_str() );
                        activate_mutation( mut_id );
                        // Action done, leave screen
                        break;
                    } else {
                        popup( _( "You don't have enough in you to activate your %s!" ), mut_data.name.c_str() );
                        redraw = true;
                        continue;
                    }
                } else {
                    popup(_("\
You cannot activate %s!  To read a description of \
%s, press '!', then '%c'."), mut_data.name.c_str(), mut_data.name.c_str(),
                          my_mutations[mut_id].key );
                    redraw = true;
                }
            }
            if (menu_mode == "examining") { // Describing mutations, not activating them!
                draw_exam_window(wBio, DESCRIPTION_LINE_Y, true);
                // Clear the lines first
                werase(w_description);
                fold_and_print(w_description, 0, 0, WIDTH - 2, c_ltblue, mut_data.description);
                wrefresh(w_description);
            }
        }
    }
    //if we activated a mutation, already killed the windows
    if(!(menu_mode == "activating")) {
        werase(wBio);
        wrefresh(wBio);
        delwin(w_title);
        delwin(w_description);
        delwin(wBio);
    }
}
Example #10
0
void sam6883_device::sam_space<_addrstart, _addrend>::point_specific_bank(const sam_bank *bank, uint32_t offset, uint32_t length, memory_bank *&memory_bank, uint32_t addrstart, uint32_t addrend, bool is_write)
{
	if (bank->m_memory != nullptr)
	{
		// this bank is a memory bank - first lets adjust the length as per the offset; as
		// passed to this method, the length is from offset zero
		if (length != ~0)
			length -= std::min(offset, length);

		// do we even have a bank?  and if so, have legit changes occured?
		if (!memory_bank || !memory_bank->matches_exactly(addrstart, addrend) || (length != m_length))
		{
			// name the bank
			auto tag = string_format("bank%04X_%c", addrstart, is_write ? 'w' : 'r');

			// determine "nop_addrstart" - where the bank ends, and above which is AM_NOP
			uint32_t nop_addrstart = (length != ~0)
				? std::min(addrend + 1, addrstart + length)
				: addrend + 1;

			// install the bank
			if (is_write)
			{
				if (addrstart < nop_addrstart)
					cpu_space().install_write_bank(addrstart, nop_addrstart - 1, 0, tag.c_str());
				if (nop_addrstart <= addrend)
					cpu_space().nop_write(nop_addrstart, addrend);
			}
			else
			{
				if (addrstart < nop_addrstart)
					cpu_space().install_read_bank(addrstart, nop_addrstart - 1, 0, tag.c_str());
				if (nop_addrstart <= addrend)
					cpu_space().nop_read(nop_addrstart, addrend);
			}

			m_length = length;

			// and get it
			memory_bank = cpu_space().device().owner()->membank(tag.c_str());
		}

		// point the bank
		if (memory_bank != nullptr)
		{
			if (is_write && bank->m_memory_read_only)
				memory_bank->set_base(m_owner.m_dummy);
			else
				memory_bank->set_base(bank->m_memory + offset);
		}
	}
	else
	{
		// this bank uses handlers - first thing's first, assert that we are not doing
		// any weird stuff with offfsets and lengths - that isn't supported in this path
		assert((offset == 0) && (length == (uint32_t)~0));

		if (is_write)
		{
			if (!bank->m_whandler.isnull())
				cpu_space().install_write_handler(addrstart, addrend, bank->m_whandler);
		}
		else
		{
			if (!bank->m_rhandler.isnull())
				cpu_space().install_read_handler(addrstart, addrend, bank->m_rhandler);
		}
	}
}
int game::inv_for_id( const itype_id &id, const std::string &title )
{
    return inv_for_filter( title, [ &id ]( const item &it ) {
        return it.typeId() == id;
    }, string_format( _( "You don't have a %s." ), item::nname( id ).c_str() ) );
}
Example #12
0
std::string item_comp::to_string( int batch ) const
{
    const int c = std::abs( count ) * batch;
    //~ <item-count> <item-name>
    return string_format( ngettext( "%d %s", "%d %s", c ), c, item::nname( type, c ).c_str() );
}
Example #13
0
std::string quality_requirement::to_string( int ) const
{
    return string_format( ngettext( "%d tool with %s of %d or more.",
                                    "%d tools with %s of %d or more.", count ),
                          count, type.obj().name.c_str(), level );
}
Example #14
0
	Font Font::load(Canvas &canvas, const std::string &family_name, const FontDescription &reference_desc, FontFamily &font_family, const XMLResourceDocument &doc, std::function<Resource<Sprite>(Canvas &, const std::string &)> cb_get_sprite)
	{
		DomElement font_element;
		XMLResourceNode resource;

		resource = doc.get_resource(family_name);
		font_element = resource.get_element();

		DomElement sprite_element = font_element.named_item("sprite").to_element();

		if (!sprite_element.is_null())
		{
			if (!sprite_element.has_attribute("glyphs"))
				throw Exception(string_format("Font resource %1 has no 'glyphs' attribute.", resource.get_name()));

			if (!sprite_element.has_attribute("letters"))
				throw Exception(string_format("Font resource %1 has no 'letters' attribute.", resource.get_name()));

			if (!cb_get_sprite)
				throw Exception(string_format("Font resource %1 requires a sprite loader callback specified.", resource.get_name()));
				
			Resource<Sprite> spr_glyphs = cb_get_sprite(canvas, sprite_element.get_attribute("glyphs"));

			const std::string &letters = sprite_element.get_attribute("letters");

			int spacelen = StringHelp::text_to_int(sprite_element.get_attribute("spacelen", "-1"));
			bool monospace = StringHelp::text_to_bool(sprite_element.get_attribute("monospace", "false"));

			// Modify the default font metrics, if specified

			float height = 0.0f;
			float line_height = 0.0f;
			float ascent = 0.0f;
			float descent = 0.0f;
			float internal_leading = 0.0f;
			float external_leading = 0.0f;

			if (sprite_element.has_attribute("height"))
				height = StringHelp::text_to_float(sprite_element.get_attribute("height", "0"));

			if (sprite_element.has_attribute("line_height"))
				line_height = StringHelp::text_to_float(sprite_element.get_attribute("line_height", "0"));

			if (sprite_element.has_attribute("ascent"))
				ascent = StringHelp::text_to_float(sprite_element.get_attribute("ascent", "0"));

			if (sprite_element.has_attribute("descent"))
				descent = StringHelp::text_to_float(sprite_element.get_attribute("descent", "0"));

			if (sprite_element.has_attribute("internal_leading"))
				internal_leading = StringHelp::text_to_float(sprite_element.get_attribute("internal_leading", "0"));

			if (sprite_element.has_attribute("external_leading"))
				external_leading = StringHelp::text_to_float(sprite_element.get_attribute("external_leading", "0"));

			FontMetrics font_metrics(height, ascent, descent, internal_leading, external_leading, line_height, canvas.get_pixel_ratio());

			font_family.add(canvas, spr_glyphs.get(), letters, spacelen, monospace, font_metrics);

			FontDescription desc = reference_desc.clone();
			return Font(font_family, desc);
		}

		DomElement ttf_element = font_element.named_item("ttf").to_element();
		if (ttf_element.is_null())
			ttf_element = font_element.named_item("freetype").to_element();

		if (!ttf_element.is_null())
		{
			FontDescription desc = reference_desc.clone();

			std::string filename;
			if (ttf_element.has_attribute("file"))
			{
				filename = PathHelp::combine(resource.get_base_path(), ttf_element.get_attribute("file"));
			}

			if (!ttf_element.has_attribute("typeface"))
				throw Exception(string_format("Font resource %1 has no 'typeface' attribute.", resource.get_name()));

			std::string font_typeface_name = ttf_element.get_attribute("typeface");

			if (ttf_element.has_attribute("height"))
				desc.set_height(ttf_element.get_attribute_int("height", 0));

			if (ttf_element.has_attribute("average_width"))
				desc.set_average_width(ttf_element.get_attribute_int("average_width", 0));

			if (ttf_element.has_attribute("anti_alias"))
				desc.set_anti_alias(ttf_element.get_attribute_bool("anti_alias", true));

			if (ttf_element.has_attribute("subpixel"))
				desc.set_subpixel(ttf_element.get_attribute_bool("subpixel", true));

			if (filename.empty())
			{
				font_family.add(font_typeface_name, desc);
				return Font(font_family, desc);
			}
			else
			{
				font_family.add(desc, filename, resource.get_file_system());
				return Font(font_family, desc);
			}
		}

		throw Exception(string_format("Font resource %1 did not have a <sprite> or <ttf> child element", resource.get_name()));
	}
void recipe_dictionary::load( JsonObject &jo, const std::string &src, bool uncraft )
{
    bool strict = src == "core";

    recipe r;

    // defer entries dependent upon as-yet unparsed definitions
    if( jo.has_string( "copy-from" ) ) {
        auto base = jo.get_string( "copy-from" );
        if( uncraft ) {
            if( !recipe_dict.uncraft.count( base ) ) {
                deferred.emplace_back( jo.str(), src );
                return;
            }
            r = recipe_dict.uncraft[ base ];
        } else {
            if( !recipe_dict.recipes.count( base ) ) {
                deferred.emplace_back( jo.str(), src );
                return;
            }
            r = recipe_dict.recipes[ base ];
        }
    }

    if( jo.has_string( "abstract" ) ) {
        r.ident_ = jo.get_string( "abstract" );
        r.abstract = true;
    } else {
        r.ident_ = r.result = jo.get_string( "result" );
        r.abstract = false;
    }

    if( !uncraft ) {
        if( jo.has_string( "id_suffix" ) ) {
            if( r.abstract ) {
                jo.throw_error( "abstract recipe cannot specify id_suffix", "id_suffix" );
            }
            r.ident_ += "_" + jo.get_string( "id_suffix" );
        }
        assign( jo, "category", r.category, strict );
        assign( jo, "subcategory", r.subcategory, strict );
        assign( jo, "reversible", r.reversible, strict );
    } else {
        r.reversible = true;
    }

    assign( jo, "time", r.time, strict, 0 );
    assign( jo, "difficulty", r.difficulty, strict, 0, MAX_SKILL );
    assign( jo, "flags", r.flags );

    // automatically set contained if we specify as container
    assign( jo, "contained", r.contained, strict );
    r.contained |= assign( jo, "container", r.container, strict );

    if( jo.has_array( "batch_time_factors" ) ) {
        auto batch = jo.get_array( "batch_time_factors" );
        r.batch_rscale = batch.get_int( 0 ) / 100.0;
        r.batch_rsize  = batch.get_int( 1 );
    }

    assign( jo, "charges", r.charges );
    assign( jo, "result_mult", r.result_mult );

    assign( jo, "skill_used", r.skill_used, strict );

    if( jo.has_member( "skills_required" ) ) {
        auto sk = jo.get_array( "skills_required" );
        r.required_skills.clear();

        if( sk.empty() ) {
            // clear all requirements

        } else if( sk.has_array( 0 ) ) {
            // multiple requirements
            while( sk.has_more() ) {
                auto arr = sk.next_array();
                r.required_skills[skill_id( arr.get_string( 0 ) )] = arr.get_int( 1 );
            }

        } else {
            // single requirement
            r.required_skills[skill_id( sk.get_string( 0 ) )] = sk.get_int( 1 );
        }
    }

    // simplified autolearn sets requirements equal to required skills at finalization
    if( jo.has_bool( "autolearn" ) ) {
        assign( jo, "autolearn", r.autolearn );

    } else if( jo.has_array( "autolearn" ) ) {
        r.autolearn = false;
        auto sk = jo.get_array( "autolearn" );
        while( sk.has_more() ) {
            auto arr = sk.next_array();
            r.autolearn_requirements[skill_id( arr.get_string( 0 ) )] = arr.get_int( 1 );
        }
    }

    if( jo.has_member( "decomp_learn" ) ) {
        r.learn_by_disassembly.clear();

        if( jo.has_int( "decomp_learn" ) ) {
            if( !r.skill_used ) {
                jo.throw_error( "decomp_learn specified with no skill_used" );
            }
            assign( jo, "decomp_learn", r.learn_by_disassembly[r.skill_used] );

        } else if( jo.has_array( "decomp_learn" ) ) {
            auto sk = jo.get_array( "decomp_learn" );
            while( sk.has_more() ) {
                auto arr = sk.next_array();
                r.learn_by_disassembly[skill_id( arr.get_string( 0 ) )] = arr.get_int( 1 );
            }
        }
    }

    if( !uncraft && jo.has_member( "byproducts" ) ) {
        auto bp = jo.get_array( "byproducts" );
        r.byproducts.clear();
        while( bp.has_more() ) {
            auto arr = bp.next_array();
            r.byproducts[ arr.get_string( 0 ) ] += arr.size() == 2 ? arr.get_int( 1 ) : 1;
        }
    }

    if( jo.has_member( "book_learn" ) ) {
        auto bk = jo.get_array( "book_learn" );
        r.booksets.clear();

        while( bk.has_more() ) {
            auto arr = bk.next_array();
            r.booksets.emplace( arr.get_string( 0 ), arr.get_int( 1 ) );
        }
    }

    // recipes not specifying any external requirements inherit from their parent recipe (if any)
    if( jo.has_string( "using" ) ) {
        r.reqs_external = { { requirement_id( jo.get_string( "using" ) ), 1 } };

    } else if( jo.has_array( "using" ) ) {
        auto arr = jo.get_array( "using" );
        r.reqs_external.clear();

        while( arr.has_more() ) {
            auto cur = arr.next_array();
            r.reqs_external.emplace_back( requirement_id( cur.get_string( 0 ) ), cur.get_int( 1 ) );
        }
    }

    // inline requirements are always replaced (cannot be inherited)
    auto req_id = string_format( "inline_%s_%s", uncraft ? "uncraft" : "recipe", r.ident_.c_str() );
    requirement_data::load_requirement( jo, req_id );
    r.reqs_internal = { { requirement_id( req_id ), 1 } };

    if( uncraft ) {
        recipe_dict.uncraft[ r.ident_ ] = r;
    } else {
        recipe_dict.recipes[ r.ident_ ] = r;
    }
}
Example #16
0
void game::wishmutate( player *p )
{
    uimenu wmenu;
    int c = 0;

    for( auto &traits_iter : mutation_branch::get_all() ) {
        wmenu.addentry( -1, true, -2, "%s", traits_iter.second.name.c_str() );
        wmenu.entries[ c ].extratxt.left = 1;
        wmenu.entries[ c ].extratxt.txt = "";
        wmenu.entries[ c ].extratxt.color = c_ltgreen;
        if( p->has_trait( traits_iter.first ) ) {
            wmenu.entries[ c ].text_color = c_green;
            if( p->has_base_trait( traits_iter.first ) ) {
                wmenu.entries[ c ].extratxt.txt = "T";
            }
        }
        c++;
    }
    wmenu.w_x = 0;
    wmenu.w_width = TERMX;
    // disabled due to foldstring crash // ( TERMX - getmaxx(w_terrain) - 30 > 24 ? getmaxx(w_terrain) : TERMX );
    wmenu.pad_right = ( wmenu.w_width - 40 );
    wmenu.return_invalid = true;
    wmenu.selected = uistate.wishmutate_selected;
    wish_mutate_callback *cb = new wish_mutate_callback();
    cb->p = p;
    wmenu.callback = cb;
    do {
        wmenu.query();
        if ( wmenu.ret >= 0 ) {
            int rc = 0;
            std::string mstr = cb->vTraits[ wmenu.ret ];
            const auto &mdata = mutation_branch::get( mstr );
            bool threshold = mdata.threshold;
            bool profession = mdata.profession;
            //Manual override for the threshold-gaining
            if (threshold || profession) {
                if ( p->has_trait( mstr ) ) {
                    do {
                        p->remove_mutation(mstr );
                        rc++;
                    } while (p->has_trait( mstr ) && rc < 10);
                } else {
                    do {
                        p->set_mutation(mstr );
                        rc++;
                    } while (!p->has_trait( mstr ) && rc < 10);
                }
            } else if ( p->has_trait( mstr ) ) {
                do {
                    p->remove_mutation(mstr );
                    rc++;
                } while (p->has_trait( mstr ) && rc < 10);
            } else {
                do {
                    p->mutate_towards(mstr );
                    rc++;
                } while (!p->has_trait( mstr ) && rc < 10);
            }
            cb->msg = string_format(_("%s Mutation changes: %d"), mstr.c_str(), rc);
            uistate.wishmutate_selected = wmenu.ret;
            if ( rc != 0 ) {
                for ( size_t i = 0; i < cb->vTraits.size(); i++ ) {
                    wmenu.entries[ i ].extratxt.txt = "";
                    if ( p->has_trait( cb->vTraits[ i ] ) ) {
                        wmenu.entries[ i ].text_color = c_green;
                        cb->pTraits[ cb->vTraits[ i ] ] = true;
                        if ( p->has_base_trait( cb->vTraits[ i ] ) ) {
                            wmenu.entries[ i ].extratxt.txt = "T";
                        }
                    } else {
                        wmenu.entries[ i ].text_color = wmenu.text_color;
                        cb->pTraits[ cb->vTraits[ i ] ] = false;
                    }
                }
            }
        }
    } while ( wmenu.keypress != 'q' && wmenu.keypress != KEY_ESCAPE && wmenu.keypress != ' ' );
    delete cb;
    cb = NULL;
    return;

}
Example #17
0
iram void io_periodic(void)
{
	const io_info_entry_t *info;
	io_data_entry_t *data;
	io_config_pin_entry_t *pin_config;
	io_data_pin_entry_t *pin_data;
	int io, pin, status_io, status_pin;
	io_flags_t flags = { .counter_triggered = 0 };
	int value;

	status_io = config.status_trigger.io;
	status_pin = config.status_trigger.pin;

	for(io = 0; io < io_id_size; io++)
	{
		info = &io_info[io];
		data = &io_data[io];

		if(!data->detected)
			continue;

		if(info->periodic_fn)
			info->periodic_fn(io, info, data, &flags);

		for(pin = 0; pin < info->pins; pin++)
		{
			pin_config = &config.io_config[io][pin];
			pin_data = &data->pin[pin];

			switch(pin_config->mode)
			{
				case(io_pin_disabled):
				case(io_pin_input_digital):
				case(io_pin_counter):
				case(io_pin_output_digital):
				case(io_pin_input_analog):
				case(io_pin_i2c):
				case(io_pin_uart):
				case(io_pin_lcd):
				case(io_pin_error):
				{
					break;
				}

				case(io_pin_timer):
				{
					if((pin_data->direction != io_dir_none) && (pin_data->speed >= 10) && ((pin_data->speed -= 10) <= 0))
					{
						switch(pin_data->direction)
						{
							case(io_dir_none):
							{
								break;
							}

							case(io_dir_up):
							{
								info->write_pin_fn((string_t *)0, info, pin_data, pin_config, pin, 1);
								pin_data->direction = io_dir_down;
								break;
							}

							case(io_dir_down):
							{
								info->write_pin_fn((string_t *)0, info, pin_data, pin_config, pin, 0);
								pin_data->direction = io_dir_up;
								break;
							}
						}

						if(pin_config->flags.repeat)
							pin_data->speed = pin_config->speed;
						else
						{
							pin_data->speed = 0;
							pin_data->direction = io_dir_none;
						}
					}

					break;
				}

				case(io_pin_trigger):
				{
					if((info->read_pin_fn((string_t *)0, info, pin_data, pin_config, pin, &value) == io_ok) && (value != 0))
					{
						io_trigger_pin((string_t *)0,
								pin_config->shared.trigger.io.io,
								pin_config->shared.trigger.io.pin,
								pin_config->shared.trigger.trigger_mode);
						info->write_pin_fn((string_t *)0, info, pin_data, pin_config, pin, 0);
					}

					break;
				}

				case(io_pin_output_analog):
				{
					if((pin_config->shared.output_analog.upper_bound > pin_config->shared.output_analog.lower_bound) &&
							(pin_config->speed > 0) && (pin_data->direction != io_dir_none))
						io_trigger_pin_x((string_t *)0, info, pin_data, pin_config, pin,
								(pin_data->direction == io_dir_up) ? io_trigger_up : io_trigger_down);

					break;
				}
			}
		}
	}

	if((flags.counter_triggered) && (status_io >= 0) && (status_pin >= 0))
		io_trigger_pin((string_t *)0, status_io, status_pin, io_trigger_on);
}

/* app commands */

irom app_action_t application_function_io_mode(const string_t *src, string_t *dst)
{
	const io_info_entry_t	*info;
	io_data_entry_t			*data;
	io_config_pin_entry_t	*pin_config;
	io_data_pin_entry_t		*pin_data;
	io_pin_mode_t			mode;
	io_pin_ll_mode_t		llmode;
	int io, pin;

	if(parse_int(1, src, &io, 0) != parse_ok)
	{
		io_config_dump(dst, &config, -1, -1, false);
		return(app_action_normal);
	}

	if((io < 0) || (io >= io_id_size))
	{
		string_format(dst, "invalid io %d\n", io);
		return(app_action_error);
	}

	info = &io_info[io];
	data = &io_data[io];

	if(!data->detected)
	{
		string_format(dst, "io %d not detected\n", io);
		return(app_action_error);
	}

	if(parse_int(2, src, &pin, 0) != parse_ok)
	{
		io_config_dump(dst, &config, io, -1, false);
		return(app_action_normal);
	}

	if((pin < 0) || (pin >= info->pins))
	{
		string_cat(dst, "io pin out of range\n");
		return(app_action_error);
	}

	pin_config = &config.io_config[io][pin];
	pin_data = &data->pin[pin];

	if(parse_string(3, src, dst) != parse_ok)
	{
		string_clear(dst);
		io_config_dump(dst, &config, io, pin, false);
		return(app_action_normal);
	}

	if((mode = io_mode_from_string(dst)) == io_pin_error)
	{
		string_copy(dst, "invalid mode\n");
		return(app_action_error);
	}

	string_clear(dst);

	llmode = io_pin_ll_error;

	switch(mode)
	{
		case(io_pin_input_digital):
		{
			if(!info->caps.input_digital)
			{
				string_cat(dst, "digital input mode invalid for this io\n");
				return(app_action_error);
			}

			llmode = io_pin_ll_input_digital;

			break;
		}

		case(io_pin_counter):
		{
			if(!info->caps.counter)
			{
				string_cat(dst, "counter mode invalid for this io\n");
				return(app_action_error);
			}

			int debounce;

			if((parse_int(4, src, &debounce, 0) != parse_ok))
			{
				string_cat(dst, "counter: <debounce ms>\n");
				return(app_action_error);
			}

			pin_config->speed = debounce;

			llmode = io_pin_ll_counter;

			break;
		}

		case(io_pin_trigger):
		{
			int debounce, trigger_io, trigger_pin;
			io_trigger_t trigger_type;

			if(!info->caps.counter)
			{
				string_cat(dst, "trigger mode invalid for this io\n");
				return(app_action_error);
			}

			if((parse_int(4, src, &debounce, 0) != parse_ok))
			{
				string_cat(dst, "trigger: <debounce ms> <io> <pin> <action>\n");
				return(app_action_error);
			}

			if((parse_int(5, src, &trigger_io, 0) != parse_ok))
			{
				string_cat(dst, "trigger: <debounce ms> <io> <pin> <action>\n");
				return(app_action_error);
			}

			if((parse_int(6, src, &trigger_pin, 0) != parse_ok))
			{
				string_cat(dst, "trigger: <debounce ms> <io> <pin> <action>\n");
				return(app_action_error);
			}

			if((parse_string(7, src, dst) != parse_ok))
			{
				string_clear(dst);
				string_cat(dst, "trigger: <debounce ms> <io> <pin> <action>\n");
				return(app_action_error);
			}

			trigger_type = string_to_trigger_type(dst);

			if(trigger_type == io_trigger_error)
			{
				string_clear(dst);
				string_cat(dst, "trigger: <io> <pin> <action>\n");
				return(app_action_error);
			}

			string_clear(dst);

			pin_config->speed = debounce;
			pin_config->shared.trigger.io.io = trigger_io;
			pin_config->shared.trigger.io.pin = trigger_pin;
			pin_config->shared.trigger.trigger_mode = trigger_type;

			llmode = io_pin_ll_counter;

			break;
		}

		case(io_pin_output_digital):
		{
			if(!info->caps.output_digital)
			{
				string_cat(dst, "digital output mode invalid for this io\n");
				return(app_action_error);
			}

			llmode = io_pin_ll_output_digital;

			break;
		}

		case(io_pin_timer):
		{
			io_direction_t direction;
			int speed;

			if(!info->caps.output_digital)
			{
				string_cat(dst, "timer mode invalid for this io\n");
				return(app_action_error);
			}

			if(parse_string(4, src, dst) != parse_ok)
			{
				string_copy(dst, "timer: <direction>:up/down <speed>:ms\n");
				return(app_action_error);
			}

			if(string_match(dst, "up"))
				direction = io_dir_up;
			else if(string_match(dst, "down"))
				direction = io_dir_down;
			else
			{
				string_cat(dst, ": timer direction invalid\n");
				return(app_action_error);
			}

			string_clear(dst);

			if((parse_int(5, src, &speed, 0) != parse_ok))
			{
				string_copy(dst, "timer: <direction>:up/down <speed>:ms\n");
				return(app_action_error);
			}

			if(speed < 10)
			{
				string_cat(dst, "timer: speed too small: must be >= 10 ms\n");
				return(app_action_error);
			}

			pin_config->direction = direction;
			pin_config->speed = speed;

			llmode = io_pin_ll_output_digital;

			break;
		}

		case(io_pin_input_analog):
		{
			if(!info->caps.input_analog)
			{
				string_cat(dst, "analog input mode invalid for this io\n");
				return(app_action_error);
			}

			llmode = io_pin_ll_input_analog;

			break;
		}

		case(io_pin_output_analog):
		{
			int lower_bound = 0;
			int upper_bound = 0;
			int speed = 0;

			if(!info->caps.output_analog)
			{
				string_cat(dst, "analog output mode invalid for this io\n");
				return(app_action_error);
			}

			parse_int(4, src, &lower_bound, 0);
			parse_int(5, src, &upper_bound, 0);
			parse_int(6, src, &speed, 0);

			if((lower_bound < 0) || (lower_bound > 65535))
			{
				string_format(dst, "outputa: lower bound out of range: %d\n", lower_bound);
				return(app_action_error);
			}

			if(upper_bound == 0)
				upper_bound = lower_bound;

			if((upper_bound < 0) || (upper_bound > 65535))
			{
				string_format(dst, "outputa: upper bound out of range: %d\n", upper_bound);
				return(app_action_error);
			}

			if(upper_bound < lower_bound)
			{
				string_cat(dst, "upper bound below lower bound\n");
				return(app_action_error);
			}

			if((speed < 0) || (speed > 65535))
			{
				string_format(dst, "outputa: speed out of range: %d\n", speed);
				return(app_action_error);
			}

			pin_config->shared.output_analog.lower_bound = lower_bound;
			pin_config->shared.output_analog.upper_bound = upper_bound;
			pin_config->speed = speed;

			llmode = io_pin_ll_output_analog;

			break;
		}

		case(io_pin_i2c):
		{
			io_i2c_t pin_mode;

			if(!info->caps.i2c)
			{
				string_cat(dst, "i2c mode invalid for this io\n");
				return(app_action_error);
			}

			if(parse_string(4, src, dst) != parse_ok)
			{
				string_copy(dst, "i2c: <pin mode>=sda|scl\n");
				return(app_action_error);
			}

			if((pin_mode = io_i2c_pin_from_string(dst)) == io_i2c_error)
			{
				string_copy(dst, "i2c: <pin mode>=sda|scl\n");
				return(app_action_error);
			}

			string_clear(dst);

			pin_config->shared.i2c.pin_mode = pin_mode;

			llmode = io_pin_ll_i2c;

			break;
		}

		case(io_pin_uart):
		{
			if(!info->caps.uart)
			{
				string_cat(dst, "uart mode invalid for this io\n");
				return(app_action_error);
			}

			llmode = io_pin_ll_uart;

			break;
		}

		case(io_pin_lcd):
		{
			io_lcd_mode_t pin_mode;

			if(parse_string(4, src, dst) != parse_ok)
			{
				string_copy(dst, "lcd: <pin use>=rs|rw|e|d0|d1|d2|d3|d4|d5|d6|d7|bl\n");
				return(app_action_error);
			}

			if((pin_mode = io_lcd_mode_from_string(dst)) == io_lcd_error)
			{
				string_copy(dst, "lcd: <pin use>=rs|rw|e|d0|d1|d2|d3|d4|d5|d6|d7|bl\n");
				return(app_action_error);
			}

			string_clear(dst);

			if(pin_mode == io_lcd_bl) // backlight
			{
				if(info->caps.output_analog)
					llmode = io_pin_ll_output_analog;
				else
					if(info->caps.output_digital)
						llmode = io_pin_ll_output_digital;
					else
					{
						string_cat(dst, "analog/digital output mode invalid for this io\n");
						return(app_action_error);
					}
			}
			else
			{
				if(!info->caps.output_digital)
				{
					string_cat(dst, "digital output mode invalid for this io\n");
					return(app_action_error);
				}

				llmode = io_pin_ll_output_digital;
			}

			pin_config->shared.lcd.pin_use = pin_mode;

			break;
		}

		case(io_pin_disabled):
		{
			llmode = io_pin_ll_disabled;

			break;
		}

		case(io_pin_error):
		{
			llmode = io_pin_ll_error;

			string_cat(dst, "unsupported io mode\n");
			return(app_action_error);
		}
	}

	if((mode == io_pin_error) || (llmode == io_pin_ll_error))
	{
		string_cat(dst, "error\n");
		return(app_action_error);
	}

	pin_config->mode = mode;
	pin_config->llmode = llmode;

	if(info->init_pin_mode_fn && (info->init_pin_mode_fn(dst, info, pin_data, pin_config, pin) != io_ok))
	{
		pin_config->mode = io_pin_disabled;
		pin_config->llmode = io_pin_ll_disabled;
		return(app_action_error);
	}

	io_config_dump(dst, &config, io, pin, false);

	return(app_action_normal);
}

irom app_action_t application_function_io_read(const string_t *src, string_t *dst)
{
	const io_info_entry_t *info;
	io_config_pin_entry_t *pin_config;
	int io, pin, value;

	if(parse_int(1, src, &io, 0) != parse_ok)
	{
		string_cat(dst, "io-read: <io> <pin>\n");
		return(app_action_error);
	}

	if((io < 0) || (io >= io_id_size))
	{
		string_format(dst, "invalid io %d\n", io);
		return(app_action_error);
	}

	info = &io_info[io];

	if(parse_int(2, src, &pin, 0) != parse_ok)
	{
		string_cat(dst, "get: <io> <pin>\n");
		return(app_action_error);
	}

	if((pin < 0) || (pin >= info->pins))
	{
		string_cat(dst, "io pin out of range\n");
		return(app_action_error);
	}

	pin_config = &config.io_config[io][pin];

	io_string_from_mode(dst, pin_config->mode);

	if(pin_config->mode == io_pin_i2c)
	{
		string_cat(dst, "/");
		io_string_from_i2c_type(dst, pin_config->shared.i2c.pin_mode);
	}

	if(pin_config->mode == io_pin_lcd)
	{
		string_cat(dst, "/");
		io_string_from_lcd_mode(dst, pin_config->shared.lcd.pin_use);
	}

	string_cat(dst, ": ");

	if(io_read_pin(dst, io, pin, &value) != io_ok)
		return(app_action_error);

	string_format(dst, "[%d]\n", value);

	return(app_action_normal);
}

irom app_action_t application_function_io_write(const string_t *src, string_t *dst)
{
	const io_info_entry_t *info;
	io_config_pin_entry_t *pin_config;
	int io, pin, value;

	if(parse_int(1, src, &io, 0) != parse_ok)
	{
		string_cat(dst, "io-write <io> <pin> <value>\n");
		return(app_action_error);
	}

	if((io < 0) || (io >= io_id_size))
	{
		string_format(dst, "invalid io %d\n", io);
		return(app_action_error);
	}

	info = &io_info[io];

	if(parse_int(2, src, &pin, 0) != parse_ok)
	{
		string_cat(dst, "io-write <io> <pin> <value>\n");
		return(app_action_error);
	}

	if((pin < 0) || (pin >= info->pins))
	{
		string_cat(dst, "invalid pin\n");
		return(app_action_error);
	}

	pin_config = &config.io_config[io][pin];

	value = 0;
	parse_int(3, src, &value, 0);

	io_string_from_mode(dst, pin_config->mode);

	if(pin_config->mode == io_pin_lcd)
	{
		string_cat(dst, "/");
		io_string_from_lcd_mode(dst, pin_config->shared.lcd.pin_use);
	}

	string_cat(dst, ": ");

	if(io_write_pin(dst, io, pin, value) != io_ok)
	{
		string_cat(dst, "\n");
		return(app_action_error);
	}

	if(io_read_pin(dst, io, pin, &value) != io_ok)
	{
		string_cat(dst, "\n");
		return(app_action_error);
	}

	string_format(dst, "[%d]\n", value);

	return(app_action_normal);
}

irom app_action_t application_function_io_trigger(const string_t *src, string_t *dst)
{
	const io_info_entry_t *info;
	int io, pin;
	io_trigger_t trigger_type;

	if(parse_int(1, src, &io, 0) != parse_ok)
		goto usage;

	if((io < 0) || (io >= io_id_size))
	{
		string_format(dst, "invalid io %d\n", io);
		return(app_action_error);
	}

	info = &io_info[io];

	if(parse_int(2, src, &pin, 0) != parse_ok)
		goto usage;

	if((pin < 0) || (pin >= info->pins))
	{
		string_cat(dst, "invalid pin\n");
		return(app_action_error);
	}

	if(parse_string(3, src, dst) != parse_ok)
		goto usage;

	if((trigger_type = string_to_trigger_type(dst)) == io_trigger_error)
		goto usage;

	string_clear(dst);

	string_cat(dst, "trigger ");
	trigger_type_to_string(trigger_type, dst);
	string_format(dst, " %u/%u: ", io, pin);

	if(io_trigger_pin(dst, io, pin, trigger_type) != io_ok)
	{
		string_cat(dst, "\n");
		return(app_action_error);
	}

	string_cat(dst, "ok\n");

	return(app_action_normal);

usage:
	string_clear(dst);
	string_cat(dst, "io-trigger <io> <pin> <action> (action = off/on/down/up)\n");
	return(app_action_error);
}

irom static app_action_t application_function_io_clear_set_flag(const string_t *src, string_t *dst, int value)
{
	const io_info_entry_t *info;
	io_data_entry_t *data;
	io_data_pin_entry_t *pin_data;
	io_config_pin_entry_t *pin_config;
	int io, pin;
	io_pin_flag_t saved_flags;

	if(parse_int(1, src, &io, 0) != parse_ok)
	{
		string_cat(dst, "io-flag <io> <pin> <flag>\n");
		return(app_action_error);
	}

	if((io < 0) || (io >= io_id_size))
	{
		string_format(dst, "invalid io %d\n", io);
		return(app_action_error);
	}

	info = &io_info[io];
	data = &io_data[io];

	if(parse_int(2, src, &pin, 0) != parse_ok)
	{
		string_cat(dst, "io-flag <io> <pin> <flag>\n");
		return(app_action_error);
	}

	if((pin < 0) || (pin >= info->pins))
	{
		string_cat(dst, "invalid pin\n");
		return(app_action_error);
	}

	pin_data = &data->pin[pin];
	pin_config = &config.io_config[io][pin];

	saved_flags = pin_config->flags;

	if((parse_string(3, src, dst) == parse_ok) && !pin_flag_from_string(dst, pin_config, value))
	{
		string_copy(dst, "io-flag <io> <pin> <flag>\n");
		return(app_action_error);
	}

	if(pin_config->flags.pullup && !info->caps.pullup)
	{
		pin_config->flags = saved_flags;
		string_copy(dst, "io does not support pullup\n");
		return(app_action_error);
	}

	if(info->init_pin_mode_fn && (info->init_pin_mode_fn(dst, info, pin_data, pin_config, pin) != io_ok))
	{
		pin_config->flags = saved_flags;
		string_copy(dst, "cannot enable this flag\n");
		return(app_action_error);
	}

	string_clear(dst);
	string_format(dst, "flags for pin %d/%d:", io, pin);

	pin_string_from_flags(dst, pin_config);

	string_cat(dst, "\n");

	return(app_action_normal);
}

irom app_action_t application_function_io_set_flag(const string_t *src, string_t *dst)
{
	return(application_function_io_clear_set_flag(src, dst, 1));
}

irom app_action_t application_function_io_clear_flag(const string_t *src, string_t *dst)
{
	return(application_function_io_clear_set_flag(src, dst, 0));
}

/* dump */

typedef enum
{
	ds_id_io,
	ds_id_pin,
	ds_id_flags_1,
	ds_id_flags_2,
	ds_id_mode,
	ds_id_disabled,
	ds_id_input,
	ds_id_counter,
	ds_id_trigger_1,
	ds_id_trigger_2,
	ds_id_output,
	ds_id_timer,
	ds_id_analog_output,
	ds_id_i2c_sda,
	ds_id_i2c_scl,
	ds_id_uart,
	ds_id_lcd,
	ds_id_unknown,
	ds_id_not_detected,
	ds_id_info_1,
	ds_id_info_2,
	ds_id_header,
	ds_id_footer,
	ds_id_preline,
	ds_id_postline,
	ds_id_error,

	ds_id_length,
	ds_id_invalid = ds_id_length
} dump_string_id_t;

typedef const char string_array_t[ds_id_length][256];

typedef struct {
	const string_array_t plain;
	const string_array_t html;
} dump_string_t;

static const roflash dump_string_t dump_strings =
{
	.plain =
	{
		"io[%d]: %s@%x",
		"  pin: %2d",
		" flags:",
		", ",
		"mode: ",
		"disabled",
		"input, state: %s",
		"counter, counter: %d, debounce: %d",
		"trigger, counter: %d, debounce: %d, io: %d, pin: %d, trigger type: ",
		"",
		"output, state: %s",
		"timer, config direction: %s, speed: %d ms, current direction: %s, delay: %d ms, state: %s",
		"analog output, min/static: %d, max: %d, current speed: %d, direction: %s, value: %d",
		"i2c/sda",
		"i2c/scl",
		"uart",
		"lcd",
		"unknown",
		"  not found\n",
		", info: ",
		"",
		"",
		"",
		"",
		"\n",
		"error",
	},

	.html =
	{
		"<td>io[%d]</td><td>%s@%x</td>",
		"<td></td><td>%d</td>",
		"<td>",
		"</td>",
		"",
		"<td>disabled</td>",
		"<td>input</td><td>state: %s</td>",
		"<td>counter</td><td><td>counter: %d</td><td>debounce: %d</td>",
		"<td>trigger</td><td>counter: %d</td><td>debounce: %d</td><td>io: %d</td><td>pin: %d</td><td>trigger type: ",
		"</td>",
		"<td>output</td><td>state: %s</td>",
		"<td>timer</td><td>config direction: %s, speed: %d ms</td><<td>current direction %s, delay: %d ms, state: %s</td>",
		"<td>analog output</td><td>min/static: %d, max: %d, speed: %d, current direction: %s, value: %d",
		"<td>i2c</td><td>sda</td>",
		"<td>i2c</td><td>scl, speed: %d</td>",
		"<td>uart</td>",
		"<td>lcd</td>",
		"<td>unknown</td>",
		"<td>not found</td>",
		"<td>",
		"</td>",
		"<table border=\"1\"><tr><th>index</th><th>name</th><th>mode</th><th colspan=\"8\"></th></tr>",
		"</table>\n",
		"<tr>",
		"</trd>\n",
		"<td>error</td>",
	}
};
Example #18
0
/*
 * Set skill on any player object; player character or NPC
 */
void game::wishskill(player *p)
{
    const int skoffset = 1;
    uimenu skmenu;
    skmenu.text = _("Select a skill to modify");
    skmenu.return_invalid = true;
    skmenu.addentry(0, true, '1', _("Modify all skills..."));

    std::vector<int> origskills;
    origskills.reserve(Skill::skills.size());

    for (auto const &s : Skill::skills) {
        auto const level = static_cast<int>(p->skillLevel(s));
        skmenu.addentry( origskills.size() + skoffset, true, -2, _( "@ %d: %s  " ), level, s.name().c_str() );
        origskills.push_back(level);
    }

    do {
        skmenu.query();
        int skill_id = -1;
        int skset = -1;
        int sksel = skmenu.selected - skoffset;
        if ( skmenu.ret == -1 && ( skmenu.keypress == KEY_LEFT || skmenu.keypress == KEY_RIGHT ) ) {
            if ( sksel >= 0 && sksel < (int)Skill::skills.size() ) {
                skill_id = sksel;
                skset = (int)p->skillLevel( Skill::skills[skill_id] ) +
                        ( skmenu.keypress == KEY_LEFT ? -1 : 1 );
            }
            skmenu.ret = -2;
        } else if ( skmenu.selected == skmenu.ret &&  sksel >= 0 && sksel < (int)Skill::skills.size() ) {
            skill_id = sksel;
            uimenu sksetmenu;
            sksetmenu.w_x = skmenu.w_x + skmenu.w_width + 1;
            sksetmenu.w_y = skmenu.w_y + 2;
            sksetmenu.w_height = skmenu.w_height - 4;
            sksetmenu.return_invalid = true;
            sksetmenu.settext( _("Set '%s' to.."), Skill::skills[skill_id].ident().c_str() );
            int skcur = (int)p->skillLevel(Skill::skills[skill_id]);
            sksetmenu.selected = skcur;
            for ( int i = 0; i < 21; i++ ) {
                sksetmenu.addentry( i, true, i + 48, "%d%s", i, (skcur == i ? _(" (current)") : "") );
            }
            sksetmenu.query();
            skset = sksetmenu.ret;
        }

        if ( skset != UIMENU_INVALID && skset != -1 && skill_id != -1 ) {
            p->skillLevel( Skill::skills[skill_id] ).level(skset);
            skmenu.textformatted[0] = string_format(_("%s set to %d             "),
                                                    Skill::skills[skill_id].ident().c_str(),
                                                    (int)p->skillLevel(Skill::skills[skill_id])).substr(0, skmenu.w_width - 4);
            skmenu.entries[skill_id + skoffset].txt = string_format(_("@ %d: %s  "),
                    (int)p->skillLevel( Skill::skills[skill_id]), Skill::skills[skill_id].ident().c_str() );
            skmenu.entries[skill_id + skoffset].text_color =
                ( (int)p->skillLevel(Skill::skills[skill_id]) == origskills[skill_id] ?
                  skmenu.text_color : c_yellow );
        } else if ( skmenu.ret == 0 && sksel == -1 ) {
            int ret = menu(true, _("Alter all skill values"), _("Add 3"), _("Add 1"), _("Subtract 1"),
                           _("Subtract 3"), _("set to 0"),
                           _("Set to 5"), _("Set to 10"), _("(Reset changes)"), NULL);
            if ( ret > 0 ) {
                int skmod = 0;
                int skset = -1;
                if (ret < 5 ) {
                    skmod = ( ret < 3 ? ( ret == 1 ? 3 : 1 ) : ( ret == 3 ? -1 : -3 ));
                } else if ( ret < 8 ) {
                    skset = ( ( ret - 5 ) * 5 );
                }
                for (size_t skill_id = 0; skill_id < Skill::skills.size(); skill_id++ ) {
                    int changeto = ( skmod != 0 ? p->skillLevel( Skill::skills[skill_id] ) + skmod :
                                     ( skset != -1 ? skset : origskills[skill_id] ) );
                    p->skillLevel( Skill::skills[skill_id] ).level( changeto );
                    skmenu.entries[skill_id + skoffset].txt = string_format(_("@ %d: %s  "),
                            (int)p->skillLevel(Skill::skills[skill_id]),
                            Skill::skills[skill_id].ident().c_str() );
                    skmenu.entries[skill_id + skoffset].text_color =
                        ( (int)p->skillLevel(Skill::skills[skill_id]) == origskills[skill_id] ?
                          skmenu.text_color : c_yellow );
                }
            }
        }
    } while ( skmenu.ret != -1 && ( skmenu.keypress != 'q' && skmenu.keypress != ' ' &&
                                    skmenu.keypress != KEY_ESCAPE ) );
}
Example #19
0
void game::wishmutate( player *p )
{
    uimenu wmenu;
    int c=0;

    for (std::map<std::string, trait>::iterator iter = traits.begin(); iter != traits.end(); ++iter) {
        wmenu.addentry(-1,true,-2,"%s",iter->second.name.c_str() );
        wmenu.entries[ c ].extratxt.left=1;
        wmenu.entries[ c ].extratxt.txt="";
        wmenu.entries[ c ].extratxt.color=c_ltgreen;
        if( p->has_trait( iter->first ) ) {
             wmenu.entries[ c ].text_color = c_green;
             if ( p->has_base_trait( iter->first ) ) {
                 wmenu.entries[ c ].extratxt.txt="T";
             }
        }
        c++;
    }
    wmenu.w_x = 0;
    wmenu.w_width = TERMX;
    // disabled due to foldstring crash // ( TERMX - getmaxx(w_terrain) - 30 > 24 ? getmaxx(w_terrain) : TERMX );
    wmenu.pad_right = ( wmenu.w_width - 30 );
    wmenu.return_invalid = true;
    wmenu.selected = uistate.wishmutate_selected;
    wish_mutate_callback *cb = new wish_mutate_callback();
    cb->g=this;
    cb->p=p;
    wmenu.callback = cb;
    do {
        wmenu.query();
        if ( wmenu.ret > 0 ) {
            int rc=0;
            std::string mstr=cb->vTraits[ wmenu.ret ];
            if ( p->has_trait( mstr ) ) {
                do {
                    p->remove_mutation(this, mstr );
                    rc++;
                } while (p->has_trait( mstr ) && rc < 10);
            } else {
                do {
                    p->mutate_towards(this, mstr );
                    rc++;
                } while (!p->has_trait( mstr ) && rc < 10);
            }
            cb->msg=string_format("%s Mutation changes: %d",mstr.c_str(),rc);
            uistate.wishmutate_selected = wmenu.ret;
            if ( rc != 0 ) {
                for ( int i = 0; i < cb->vTraits.size(); i++ ) {
                    wmenu.entries[ i ].extratxt.txt="";
                    if ( p->has_trait( cb->vTraits[ i ] ) ) {
                        wmenu.entries[ i ].text_color = c_green;
                        cb->pTraits[ cb->vTraits[ i ] ] = true;
                        if ( p->has_base_trait( cb->vTraits[ i ] ) ) {
                            wmenu.entries[ i ].extratxt.txt="T";
                        }
                    } else {
                        wmenu.entries[ i ].text_color = wmenu.text_color;
                        cb->pTraits[ cb->vTraits[ i ] ] = false;
                    }
                }
            }
        }
    } while ( wmenu.keypress != 'q' && wmenu.keypress != KEY_ESCAPE && wmenu.keypress != ' ' );
    delete cb;
    cb = NULL;
    return;

}
Example #20
0
static int
fakens_search(const uschar *domain, int type, uschar *answerptr, int size)
{
int len = Ustrlen(domain);
int asize = size;                  /* Locally modified */
uschar name[256];
uschar utilname[256];
uschar *aptr = answerptr;          /* Locally modified */
struct stat statbuf;

/* Remove terminating dot. */

if (domain[len - 1] == '.') len--;
Ustrncpy(name, domain, len);
name[len] = 0;

/* Look for the fakens utility, and if it exists, call it. */

(void)string_format(utilname, sizeof(utilname), "%s/bin/fakens",
  config_main_directory);

if (stat(CS utilname, &statbuf) >= 0)
  {
  pid_t pid;
  int infd, outfd, rc;
  uschar *argv[5];

  DEBUG(D_dns) debug_printf("DNS lookup of %s (%s) using fakens\n", name, dns_text_type(type));

  argv[0] = utilname;
  argv[1] = config_main_directory;
  argv[2] = name;
  argv[3] = dns_text_type(type);
  argv[4] = NULL;

  pid = child_open(argv, NULL, 0000, &infd, &outfd, FALSE);
  if (pid < 0)
    log_write(0, LOG_MAIN|LOG_PANIC_DIE, "failed to run fakens: %s",
      strerror(errno));

  len = 0;
  rc = -1;
  while (asize > 0 && (rc = read(outfd, aptr, asize)) > 0)
    {
    len += rc;
    aptr += rc;       /* Don't modify the actual arguments, because they */
    asize -= rc;      /* may need to be passed on to res_search(). */
    }

  /* If we ran out of output buffer before exhausting the return,
  carry on reading and counting it. */

  if (asize == 0)
    while ((rc = read(outfd, name, sizeof(name))) > 0)
      len += rc;

  if (rc < 0)
    log_write(0, LOG_MAIN|LOG_PANIC_DIE, "read from fakens failed: %s",
      strerror(errno));

  switch(child_close(pid, 0))
    {
    case 0: return len;
    case 1: h_errno = HOST_NOT_FOUND; return -1;
    case 2: h_errno = TRY_AGAIN; return -1;
    default:
    case 3: h_errno = NO_RECOVERY; return -1;
    case 4: h_errno = NO_DATA; return -1;
    case 5: /* Pass on to res_search() */
    DEBUG(D_dns) debug_printf("fakens returned PASS_ON\n");
    }
  }
else
  {
  DEBUG(D_dns) debug_printf("fakens (%s) not found\n", utilname);
  }

/* fakens utility not found, or it returned "pass on" */

DEBUG(D_dns) debug_printf("passing %s on to res_search()\n", domain);

return res_search(CS domain, C_IN, type, answerptr, size);
}
Example #21
0
std::string weather_forecast(radio_tower tower)
{
    std::stringstream weather_report;
    // Local conditions
    city *closest_city = &g->cur_om->cities[g->cur_om->closest_city(point(tower.x, tower.y))];
    // Current time
    weather_report << string_format(
        _("The current time is %s Eastern Standard Time.  At %s in %s, it was %s. The temperature was %s"),
        g->turn.print_time().c_str(), g->turn.print_time(true).c_str(), closest_city->name.c_str(),
        weather_data[g->weather].name.c_str(), print_temperature(g->temperature).c_str()
    );

    //weather_report << ", the dewpoint ???, and the relative humidity ???.  ";
    //weather_report << "The wind was <direction> at ? mi/km an hour.  ";
    //weather_report << "The pressure was ??? in/mm and steady/rising/falling.";

    // Regional conditions (simulated by chosing a random range containing the current conditions).
    // Adjusted for weather volatility based on how many weather changes are coming up.
    //weather_report << "Across <region>, skies ranged from <cloudiest> to <clearest>.  ";
    // TODO: Add fake reports for nearby cities

    // TODO: weather forecast
    // forecasting periods are divided into 12-hour periods, day (6-18) and night (19-5)
    // Accumulate percentages for each period of various weather statistics, and report that
    // (with fuzz) as the weather chances.
    int weather_proportions[NUM_WEATHER_TYPES] = {0};
    signed char high = 0;
    signed char low = 0;
    calendar start_time = g->turn;
    int period_start = g->turn.hours();
    // TODO wind direction and speed
    for(std::map<int, weather_segment>::iterator it = g->weather_log.lower_bound( int(g->turn) ); it != g->weather_log.end(); ++it ) {
        weather_segment * period = &(it->second);
        int period_deadline = period->deadline.hours();
        signed char period_temperature = period->temperature;
        weather_type period_weather = period->weather;
        bool start_day = period_start >= 6 && period_start <= 18;
        bool end_day = period_deadline >= 6 && period_deadline <= 18;

        high = std::max(high, period_temperature);
        low = std::min(low, period_temperature);

        if(start_day != end_day) // Assume a period doesn't last over 12 hrs?
        {
            weather_proportions[period_weather] += end_day ? 6 : 18 - period_start;
            int weather_duration = 0;
            int predominant_weather = 0;
            std::string day;
            if( g->turn.days() == period->deadline.days() )
            {
                if( start_day )
                {
                    day = _("Today");
                }
                else
                {
                    day = _("Tonight");
                }
            }
            else
            {
                std::string dayofweak = start_time.day_of_week();
                if( !start_day )
                {
                    day = rmp_format(_("<Mon Night>%s Night"), dayofweak.c_str());
                }
                else
                {
                    day = dayofweak;
                }
            }
            for( int i = WEATHER_CLEAR; i < NUM_WEATHER_TYPES; i++)
            {
                if( weather_proportions[i] > weather_duration)
                {
                    weather_duration = weather_proportions[i];
                    predominant_weather = i;
                }
            }
            // Print forecast
            weather_report << string_format(
                _("%s...%s. Highs of %s. Lows of %s. "),
                day.c_str(), weather_data[predominant_weather].name.c_str(),
                print_temperature(high).c_str(), print_temperature(low).c_str()
            );
            low = period_temperature;
            high = period_temperature;
            weather_proportions[period_weather] += end_day ? 6 : 18 - period_start;
        } else {
            weather_proportions[period_weather] += period_deadline - period_start;
        }
        start_time = period->deadline;
        period_start = period_deadline;
    }
    return weather_report.str();
}
Example #22
0
void mod_manager::load_modfile(JsonObject &jo, const std::string &main_path)
{
    if (!jo.has_string("type") || jo.get_string("type") != "MOD_INFO") {
        // Ignore anything that is not a mod-info
        return;
    }
    std::string m_ident = jo.get_string("ident");
    if (has_mod(m_ident)) {
        // TODO: change this to make unique ident for the mod
        // (instead of discarding it?)
        debugmsg("there is already a mod with ident %s", m_ident.c_str());
        return;
    }
    if( jo.has_bool( "obsolete" ) ) {
        // Marked obsolete, no need to try to load anything else.
        MOD_INFORMATION *modfile = new MOD_INFORMATION;
        modfile->ident = m_ident;
        modfile->obsolete = true;
        mod_map[modfile->ident] = modfile;
        return;
    }

    std::string t_type = jo.get_string("mod-type", "SUPPLEMENTAL");
    std::vector<std::string> m_authors;
    if (jo.has_array("authors")) {
        m_authors = jo.get_string_array("authors");
    } else {
        if(jo.has_string("author")) {
            m_authors.push_back(jo.get_string("author"));
        }
    }
    std::string m_name = jo.get_string("name", "");
    if (m_name.empty()) {
        // "No name" gets confusing if many mods have no name
        //~ name of a mod that has no name entry, (%s is the mods identifier)
        m_name = string_format(_("No name (%s)"), m_ident.c_str());
    } else {
        m_name = _(m_name.c_str());
    }
    std::string m_desc = jo.get_string("description", "");
    if (m_desc.empty()) {
        m_desc = _("No description");
    } else {
        m_desc = _(m_desc.c_str());
    }
    std::string m_path;
    if (jo.has_string("path")) {
        m_path = jo.get_string("path");
        if (m_path.empty()) {
            // If an empty path is given, use only the
            // folder of the modinfo.json
            m_path = main_path;
        } else {
            // prefix the folder of modinfo.json
            m_path = main_path + "/" + m_path;
        }
    } else {
        // Default if no path is given:
        // "<folder-of-modinfo.json>/data"
        m_path = main_path + "/data";
    }
    std::vector<std::string> m_dependencies;

    if (jo.has_member("dependencies") && jo.has_array("dependencies")) {
        JsonArray jarr = jo.get_array("dependencies");
        while(jarr.has_more()) {
            const std::string dep = jarr.next_string();
            if (dep == m_ident) {
                debugmsg("mod %s has itself as dependency", m_ident.c_str());
                continue;
            }
            if (std::find(m_dependencies.begin(), m_dependencies.end(), dep) != m_dependencies.end()) {
                // Some dependency listed twice, ignore it, what else can be done?
                continue;
            }
            m_dependencies.push_back(dep);
        }
    }

    mod_type m_type;
    if (t_type == "CORE") {
        m_type = MT_CORE;
    } else if (t_type == "SUPPLEMENTAL") {
        m_type = MT_SUPPLEMENTAL;
    } else {
        throw std::string("Invalid mod type: ") + t_type + " for mod " + m_ident;
    }

    MOD_INFORMATION *modfile = new MOD_INFORMATION;
    modfile->ident = m_ident;
    modfile->_type = m_type;
    modfile->authors = m_authors;
    modfile->name = m_name;
    modfile->description = m_desc;
    modfile->dependencies = m_dependencies;
    modfile->path = m_path;

    mod_map[modfile->ident] = modfile;
}
	void OpenGLWindowProvider::create(DisplayWindowSite *new_site, const DisplayWindowDescription &desc)
	{
		site = new_site;
		fullscreen = desc.is_fullscreen();

		win32_window.create(site, desc);

		if (!opengl_context)
		{
			HWND handle = win32_window.get_hwnd();
			dwm_layered = false;

			if (desc.is_layered() && !DwmFunctions::is_composition_enabled())
			{
				create_shadow_window(handle);
			}
			else
			{
				if (desc.is_layered())
					dwm_layered = true;
			}

			desc.is_layered() ? double_buffered = false : double_buffered = true;	// Only can use Layered windows that are single buffered with OpenGL (via shadow window) ( PFD_DOUBLEBUFFER_DONTCARE set in OpenGLCreationHelper::set_multisampling_pixel_format)

			device_context = GetDC(handle);

			HGLRC share_context = get_share_context();

			OpenGLCreationHelper helper(handle, device_context);
			helper.set_multisampling_pixel_format(desc);

			int gl_major = opengl_desc.get_version_major();
			int gl_minor = opengl_desc.get_version_minor();
			if (opengl_desc.get_allow_lower_versions() == false)
			{
				opengl_context = helper.create_opengl3_context(share_context, gl_major, gl_minor, opengl_desc);
				if (!opengl_context)
					throw Exception(string_format("This application requires OpenGL %1.%2 or above. Try updating your drivers, or upgrade to a newer graphics card.", gl_major, gl_minor));
			}
			else
			{
				static const char opengl_version_list[] =
				{
					// Clanlib supported version pairs
					4, 5,
					4, 4,
					4, 3,
					4, 2,
					4, 1,
					4, 0,
					3, 3,
					3, 2,
					3, 1,
					3, 0,
					0, 0,	// End of list
				};

				const char *opengl_version_list_ptr = opengl_version_list;
				do
				{
					int major = *(opengl_version_list_ptr++);
					if (major == 0)
						break;

					int minor = *(opengl_version_list_ptr++);

					// Find the appropriate version in the list
					if (major > gl_major)
						continue;

					if (major == gl_major)
					{
						if (minor > gl_minor)
							continue;
					}

					opengl_context = helper.create_opengl3_context(share_context, major, minor, opengl_desc);
				} while (!opengl_context);

				if (!opengl_context)
					opengl_context = helper.create_opengl2_context(share_context);

				if (!opengl_context)
					throw Exception("This application requires OpenGL. Try updating your drivers, or upgrade to a newer graphics card.");

			}

			bool use_gl3;
			int desc_version_major = opengl_desc.get_version_major();
			int desc_version_minor = opengl_desc.get_version_minor();

			// Do not attempt GL3, if not requested that version
			if (desc_version_major < 3)
			{
				use_gl3 = false;
			}
			else if (!opengl_desc.get_allow_lower_versions())	// Else, if we do not allow lower versions, only attempt GL3
			{
				use_gl3 = true;
			}
			else
			{
				// Choose the target depending on the current opengl version
				int gl_version_major;
				int gl_version_minor;
				get_opengl_version(gl_version_major, gl_version_minor);
				if (gl_version_major < 3)
				{
					use_gl3 = false;
				}
				else
				{
					use_gl3 = true;
				}

			}

			if (use_gl3)
			{
				using_gl3 = true;
				gc = GraphicContext(new GL3GraphicContextProvider(this));
			}
			else
			{
				using_gl3 = false;
				gc = GraphicContext(new GL1GraphicContextProvider(this));
			}
		}

		wglSwapIntervalEXT = (ptr_wglSwapIntervalEXT)OpenGL::get_proc_address("wglSwapIntervalEXT");
		swap_interval = desc.get_swap_interval();
		if (wglSwapIntervalEXT && swap_interval != -1)
			wglSwapIntervalEXT(swap_interval);
	}
Example #24
0
NetGameEventValue NetGameEvent::get_argument(unsigned int index) const
{
	if (index >= arguments.size())
		throw Exception(string_format("Arguments out of bounds for game event %1", name));
	return arguments[index];
}
Example #25
0
void mission_start::place_npc_software(game *g, mission *miss)
{
 npc* dev = g->find_npc(miss->npc_id);
 if (dev == NULL) {
  debugmsg("Couldn't find NPC! %d", miss->npc_id);
  return;
 }
 g->u.i_add( item(g->itypes["usb_drive"], 0) );
 g->add_msg(_("%s gave you a USB drive."), dev->name.c_str());

 oter_id ter = ot_house_north;

 switch (dev->myclass) {
 case NC_HACKER:
  miss->item_id = "software_hacking";
  break;
 case NC_DOCTOR:
  miss->item_id = "software_medical";
  ter = ot_s_pharm_north;
  miss->follow_up = MISSION_GET_ZOMBIE_BLOOD_ANAL;
  break;
 case NC_SCIENTIST:
  miss->item_id = "software_math";
  break;
 default:
  miss->item_id = "software_useless";
 }

 int dist = 0;
 point place;
 if (ter == ot_house_north) {
  int city_id = g->cur_om->closest_city( g->om_location() );
  place = g->cur_om->random_house_in_city(city_id);
 } else
  place = g->cur_om->find_closest(g->om_location(), ter, 4, dist, false);
 miss->target = place;
// Make it seen on our map
 for (int x = place.x - 6; x <= place.x + 6; x++) {
  for (int y = place.y - 6; y <= place.y + 6; y++)
   g->cur_om->seen(x, y, 0) = true;
 }
 tinymap compmap(&(g->traps));
 compmap.load(g, place.x * 2, place.y * 2, 0, false);
 point comppoint;

 switch (g->cur_om->ter(place.x, place.y, 0)) {
 case ot_house_north:
 case ot_house_east:
 case ot_house_west:
 case ot_house_south: {
  std::vector<point> valid;
  for (int x = 0; x < SEEX * 2; x++) {
   for (int y = 0; y < SEEY * 2; y++) {
    if (compmap.ter(x, y) == t_floor && compmap.furn(x, y) == f_null) {
     bool okay = false;
     for (int x2 = x - 1; x2 <= x + 1 && !okay; x2++) {
      for (int y2 = y - 1; y2 <= y + 1 && !okay; y2++) {
       if (compmap.furn(x2, y2) == f_bed || compmap.furn(x2, y2) == f_dresser) {
        okay = true;
        valid.push_back( point(x, y) );
       }
      }
     }
    }
   }
  }
  if (valid.empty())
   comppoint = point( rng(6, SEEX * 2 - 7), rng(6, SEEY * 2 - 7) );
  else
   comppoint = valid[rng(0, valid.size() - 1)];
 } break;
 case ot_s_pharm_north: {
  bool found = false;
  for (int x = SEEX * 2 - 1; x > 0 && !found; x--) {
   for (int y = SEEY * 2 - 1; y > 0 && !found; y--) {
    if (compmap.ter(x, y) == t_floor) {
     found = true;
     comppoint = point(x, y);
    }
   }
  }
 } break;
 case ot_s_pharm_east: {
  bool found = false;
  for (int x = 0; x < SEEX * 2 && !found; x++) {
   for (int y = SEEY * 2 - 1; y > 0 && !found; y--) {
    if (compmap.ter(x, y) == t_floor) {
     found = true;
     comppoint = point(x, y);
    }
   }
  }
 } break;
 case ot_s_pharm_south: {
  bool found = false;
  for (int x = 0; x < SEEX * 2 && !found; x++) {
   for (int y = 0; y < SEEY * 2 && !found; y++) {
    if (compmap.ter(x, y) == t_floor) {
     found = true;
     comppoint = point(x, y);
    }
   }
  }
 } break;
 case ot_s_pharm_west: {
  bool found = false;
  for (int x = SEEX * 2 - 1; x > 0 && !found; x--) {
   for (int y = 0; y < SEEY * 2 && !found; y++) {
    if (compmap.ter(x, y) == t_floor) {
     found = true;
     comppoint = point(x, y);
    }
   }
  }
 } break;
 }

 compmap.ter_set(comppoint.x, comppoint.y, t_console);
 computer *tmpcomp = compmap.add_computer(comppoint.x, comppoint.y, string_format(_("%s's Terminal"), dev->name.c_str()), 0);
 tmpcomp->mission_id = miss->uid;
 tmpcomp->add_option(_("Download Software"), COMPACT_DOWNLOAD_SOFTWARE, 0);

 compmap.save(g->cur_om, int(g->turn), place.x * 2, place.y * 2, 0);
}
void mission_start::place_npc_software(mission *miss)
{
 npc* dev = g->find_npc(miss->npc_id);
 if (dev == NULL) {
  debugmsg("Couldn't find NPC! %d", miss->npc_id);
  return;
 }
 g->u.i_add( item("usb_drive", 0) );
 add_msg(_("%s gave you a USB drive."), dev->name.c_str());

 std::string type = "house";

 switch (dev->myclass) {
 case NC_HACKER:
  miss->item_id = "software_hacking";
  break;
 case NC_DOCTOR:
  miss->item_id = "software_medical";
  type = "s_pharm";
  miss->follow_up = MISSION_GET_ZOMBIE_BLOOD_ANAL;
  break;
 case NC_SCIENTIST:
  miss->item_id = "software_math";
  break;
 default:
  miss->item_id = "software_useless";
 }

    int dist = 0;
    point place;
    if (type == "house") {
        int city_id = g->cur_om->closest_city( g->om_location() );
        place = g->cur_om->random_house_in_city(city_id);
        // make it global coordinates
        place.x += g->cur_om->pos().x * OMAPX;
        place.y += g->cur_om->pos().y * OMAPY;
    } else {
        place = overmap_buffer.find_closest(g->om_global_location(), type, dist, false);
    }
    miss->target = place;
    overmap_buffer.reveal(place, 6, g->levz);

 tinymap compmap;
 compmap.load_abs(place.x * 2, place.y * 2, g->levz, false);
 point comppoint;

    oter_id oter = g->cur_om->ter(place.x, place.y, 0);
    if (oter == "house_north" || oter == "house_east"
            || oter == "house_south" || oter == "house_west") {
        std::vector<point> valid;
        for (int x = 0; x < SEEX * 2; x++) {
            for (int y = 0; y < SEEY * 2; y++) {
                if (compmap.ter(x, y) == t_floor && compmap.furn(x, y) == f_null) {
                    bool okay = false;
                    for (int x2 = x - 1; x2 <= x + 1 && !okay; x2++) {
                        for (int y2 = y - 1; y2 <= y + 1 && !okay; y2++) {
                            if (compmap.furn(x2, y2) == f_bed || compmap.furn(x2, y2) == f_dresser) {
                                okay = true;
                                valid.push_back( point(x, y) );
                            }
                        }
                    }
                }
            }
        }
        if (valid.empty()) {
            comppoint = point( rng(6, SEEX * 2 - 7), rng(6, SEEY * 2 - 7) );
        } else {
            comppoint = valid[rng(0, valid.size() - 1)];
        }
    } else if (oter == "s_pharm_north") {
        bool found = false;
        for (int x = SEEX * 2 - 1; x > 0 && !found; x--) {
            for (int y = SEEY * 2 - 1; y > 0 && !found; y--) {
                if (compmap.ter(x, y) == t_floor) {
                    found = true;
                    comppoint = point(x, y);
                }
            }
        }
    } else if (oter == "s_pharm_east") {
        bool found = false;
        for (int x = 0; x < SEEX * 2 && !found; x++) {
            for (int y = SEEY * 2 - 1; y > 0 && !found; y--) {
                if (compmap.ter(x, y) == t_floor) {
                    found = true;
                    comppoint = point(x, y);
                }
            }
        }
    } else if (oter == "s_pharm_south") {
        bool found = false;
        for (int x = 0; x < SEEX * 2 && !found; x++) {
            for (int y = 0; y < SEEY * 2 && !found; y++) {
                if (compmap.ter(x, y) == t_floor) {
                    found = true;
                    comppoint = point(x, y);
                }
            }
        }
    } else if (oter == "s_pharm_west") {
        bool found = false;
        for (int x = SEEX * 2 - 1; x > 0 && !found; x--) {
            for (int y = 0; y < SEEY * 2 && !found; y++) {
                if (compmap.ter(x, y) == t_floor) {
                    found = true;
                    comppoint = point(x, y);
                }
            }
        }
    }

 compmap.ter_set(comppoint.x, comppoint.y, t_console);
 computer *tmpcomp = compmap.add_computer(comppoint.x, comppoint.y, string_format(_("%s's Terminal"), dev->name.c_str()), 0);
 tmpcomp->mission_id = miss->uid;
 tmpcomp->add_option(_("Download Software"), COMPACT_DOWNLOAD_SOFTWARE, 0);
 compmap.save();
}
Example #27
0
std::string tpanelload_pending_op::dump() {
	std::shared_ptr<tpanel> tp=pushtpanel.lock();
	tpanelparentwin_nt *window=win.get();
	return string_format("Push tweet to tpanel: %s, window: %p, pushflags: 0x%X", (tp) ? cstr(wxstrstd(tp->dispname)) : "N/A", window, pushflags);
}
Example #28
0
 /// @return hardware GUID in URN format to identify hardware as uniquely as possible
 virtual string hardwareGUID() { return string_format("sparkcoreid:%s", sparkCoreID.c_str()); }
Example #29
0
std::string machine_info::game_info_string()
{
	std::ostringstream buf;

	// print description, manufacturer, and CPU:
	util::stream_format(buf, _("%1$s\n%2$s %3$s\nDriver: %4$s\n\nCPU:\n"),
			m_machine.system().description,
			m_machine.system().year,
			m_machine.system().manufacturer,
			core_filename_extract_base(m_machine.system().source_file));

	// loop over all CPUs
	execute_interface_iterator execiter(m_machine.root_device());
	std::unordered_set<std::string> exectags;
	for (device_execute_interface &exec : execiter)
	{
		if (!exectags.insert(exec.device().tag()).second)
			continue;
		// get cpu specific clock that takes internal multiplier/dividers into account
		int clock = exec.device().clock();

		// count how many identical CPUs we have
		int count = 1;
		const char *name = exec.device().name();
		for (device_execute_interface &scan : execiter)
		{
			if (exec.device().type() == scan.device().type() && strcmp(name, scan.device().name()) == 0 && exec.device().clock() == scan.device().clock())
				if (exectags.insert(scan.device().tag()).second)
					count++;
		}

		// if more than one, prepend a #x in front of the CPU name
		// display clock in kHz or MHz
		util::stream_format(buf,
				(count > 1) ? "%1$d" UTF8_MULTIPLY "%2$s %3$d.%4$0*5$d%6$s\n" : "%2$s %3$d.%4$0*5$d%6$s\n",
				count,
				name,
				(clock >= 1000000) ? (clock / 1000000) : (clock / 1000),
				(clock >= 1000000) ? (clock % 1000000) : (clock % 1000),
				(clock >= 1000000) ? 6 : 3,
				(clock >= 1000000) ? _("MHz") : _("kHz"));
	}

	// loop over all sound chips
	sound_interface_iterator snditer(m_machine.root_device());
	std::unordered_set<std::string> soundtags;
	bool found_sound = false;
	for (device_sound_interface &sound : snditer)
	{
		if (!sound.issound() || !soundtags.insert(sound.device().tag()).second)
			continue;

		// append the Sound: string
		if (!found_sound)
			buf << _("\nSound:\n");
		found_sound = true;

		// count how many identical sound chips we have
		int count = 1;
		for (device_sound_interface &scan : snditer)
		{
			if (sound.device().type() == scan.device().type() && sound.device().clock() == scan.device().clock())
				if (soundtags.insert(scan.device().tag()).second)
					count++;
		}

		// if more than one, prepend a #x in front of the CPU name
		// display clock in kHz or MHz
		int clock = sound.device().clock();
		util::stream_format(buf,
				(count > 1)
					? ((clock != 0) ? "%1$d" UTF8_MULTIPLY "%2$s %3$d.%4$0*5$d%6$s\n" : "%1$d" UTF8_MULTIPLY "%2$s\n")
					: ((clock != 0) ? "%2$s %3$d.%4$0*5$d%6$s\n" : "%2$s\n"),
				count,
				sound.device().name(),
				(clock >= 1000000) ? (clock / 1000000) : (clock / 1000),
				(clock >= 1000000) ? (clock % 1000000) : (clock % 1000),
				(clock >= 1000000) ? 6 : 3,
				(clock >= 1000000) ? _("MHz") : _("kHz"));
	}

	// display screen information
	buf << _("\nVideo:\n");
	screen_device_iterator scriter(m_machine.root_device());
	int scrcount = scriter.count();
	if (scrcount == 0)
		buf << _("None\n");
	else
	{
		for (screen_device &screen : scriter)
		{
			std::string detail;
			if (screen.screen_type() == SCREEN_TYPE_VECTOR)
				detail = _("Vector");
			else
			{
				const rectangle &visarea = screen.visible_area();
				detail = string_format("%d " UTF8_MULTIPLY " %d (%s) %f" UTF8_NBSP "Hz",
						visarea.width(), visarea.height(),
						(m_machine.system().flags & ORIENTATION_SWAP_XY) ? "V" : "H",
						ATTOSECONDS_TO_HZ(screen.frame_period().attoseconds()));
			}

			util::stream_format(buf,
					(scrcount > 1) ? _("%1$s: %2$s\n") : _("%2$s\n"),
					get_screen_desc(screen), detail);
		}
	}

	return buf.str();
}
Example #30
0
irom app_action_t application_function_ota_send(const string_t *src, string_t *dst)
{
	int chunk_offset, chunk_length, remote_chunk_length;
	uint32_t crc, remote_crc;
	app_action_t action;

	if((ota_state != state_write) && (ota_state != state_verify))
	{
		string_cat(dst, "OTA: not active\n");
		ota_state = state_inactive;
		return(app_action_error);
	}

	if(parse_int(1, src, &remote_chunk_length, 0) != parse_ok)
	{
		string_cat(dst, "OTA: missing chunk length\n");
		ota_state = state_inactive;
		return(app_action_error);
	}

	if(parse_int(2, src, &remote_crc, 0) != parse_ok)
	{
		string_cat(dst, "OTA: missing crc\n");
		ota_state = state_inactive;
		return(app_action_error);
	}

	if((chunk_offset = string_sep(src, 0, 3, ' ')) < 0)
	{
		string_cat(dst, "OTA: missing data chunk\n");
		ota_state = state_inactive;
		return(app_action_error);
	}

	if((chunk_length = string_length(src) - chunk_offset) != remote_chunk_length)
	{
		string_format(dst, "OTA: chunk length mismatch: %d != %d\n", remote_chunk_length, chunk_length);
		ota_state = state_inactive;
		return(app_action_error);
	}

	if((crc = string_crc32(src, chunk_offset, chunk_length)) != remote_crc)
	{
		string_format(dst, "OTA: CRC mismatch %08x != %08x\n", remote_crc, crc);
		ota_state = state_inactive;
		return(app_action_error);
	}

	string_splice(&buffer_4k, src, chunk_offset, chunk_length);

	if(string_length(&buffer_4k) > 0x1000)
	{
		string_format(dst, "OTA: unaligned %u\n", string_length(&buffer_4k));
		ota_state = state_inactive;
		return(app_action_error);
	}

	if((string_length(&buffer_4k) == 0x1000) &&
			((action = flash_write_verify(src, dst)) != app_action_normal))
	{
		ota_state = state_inactive;
		return(action);
	}

	string_format(dst, "ACK %d\n", received);

	return(app_action_normal);
}