Translated using Weblate (Occitan) - minetest.git - modified minetest for gpcfs purposes

diff options

author	Walter Bulbazor <prbulbazor@protonmail.com>	2022-07-19 08:53:23 +0000
committer	sfan5 <sfan5@live.de>	2022-07-20 21:28:27 +0200
commit	71f083d4ad8df472e944b2bf0d5d89f70d66a0cd (patch)
tree	83387658dcf92e18d17ac0aed998f3433e79becf /po/oc
parent	32ef0678e55b33e3668da83c5b766edbd6dadb30 (diff)
download	minetest-71f083d4ad8df472e944b2bf0d5d89f70d66a0cd.tar.gz minetest-71f083d4ad8df472e944b2bf0d5d89f70d66a0cd.tar.bz2 minetest-71f083d4ad8df472e944b2bf0d5d89f70d66a0cd.zip

Translated using Weblate (Occitan)

Currently translated at 1.3% (19 of 1416 strings)

Diffstat (limited to 'po/oc')

-rw-r--r--

po/oc/minetest.po

1 files changed, 26 insertions, 21 deletions

/* Minetest Copyright (C) 2013 celeron55, Perttu Ahola <celeron55@gmail.com> This program is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with this program; if not, write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. */ #include "nodedef.h" #include "itemdef.h" #ifndef SERVER #include "mesh.h" #include "shader.h" #include "client.h" #include "client/renderingengine.h" #include "client/tile.h" #include <IMeshManipulator.h> #endif #include "log.h" #include "settings.h" #include "nameidmapping.h" #include "util/numeric.h" #include "util/serialize.h" #include "exceptions.h" #include "debug.h" #include "gamedef.h" #include "mapnode.h" #include <fstream> // Used in applyTextureOverrides() #include <algorithm> #include <cmath> /* NodeBox */ void NodeBox::reset() { type = NODEBOX_REGULAR; // default is empty fixed.clear(); // default is sign/ladder-like wall_top = aabb3f(-BS/2, BS/2-BS/16., -BS/2, BS/2, BS/2, BS/2); wall_bottom = aabb3f(-BS/2, -BS/2, -BS/2, BS/2, -BS/2+BS/16., BS/2); wall_side = aabb3f(-BS/2, -BS/2, -BS/2, -BS/2+BS/16., BS/2, BS/2); // no default for other parts connect_top.clear(); connect_bottom.clear(); connect_front.clear(); connect_left.clear(); connect_back.clear(); connect_right.clear(); } void NodeBox::serialize(std::ostream &os, u16 protocol_version) const { // Protocol >= 36 int version = 4; writeU8(os, version); switch (type) { case NODEBOX_LEVELED: case NODEBOX_FIXED: writeU8(os, type); writeU16(os, fixed.size()); for (const aabb3f &nodebox : fixed) { writeV3F1000(os, nodebox.MinEdge); writeV3F1000(os, nodebox.MaxEdge); } break; case NODEBOX_WALLMOUNTED: writeU8(os, type); writeV3F1000(os, wall_top.MinEdge); writeV3F1000(os, wall_top.MaxEdge); writeV3F1000(os, wall_bottom.MinEdge); writeV3F1000(os, wall_bottom.MaxEdge); writeV3F1000(os, wall_side.MinEdge); writeV3F1000(os, wall_side.MaxEdge); break; case NODEBOX_CONNECTED: writeU8(os, type); #define WRITEBOX(box) \ writeU16(os, (box).size()); \ for (const aabb3f &i: (box)) { \ writeV3F1000(os, i.MinEdge); \ writeV3F1000(os, i.MaxEdge); \ }; WRITEBOX(fixed); WRITEBOX(connect_top); WRITEBOX(connect_bottom); WRITEBOX(connect_front); WRITEBOX(connect_left); WRITEBOX(connect_back); WRITEBOX(connect_right); break; default: writeU8(os, type); break; } } void NodeBox::deSerialize(std::istream &is) { int version = readU8(is); if (version < 4) throw SerializationError("unsupported NodeBox version"); reset(); type = (enum NodeBoxType)readU8(is); if(type == NODEBOX_FIXED || type == NODEBOX_LEVELED) { u16 fixed_count = readU16(is); while(fixed_count--) { aabb3f box; box.MinEdge = readV3F1000(is); box.MaxEdge = readV3F1000(is); fixed.push_back(box); } } else if(type == NODEBOX_WALLMOUNTED) { wall_top.MinEdge = readV3F1000(is); wall_top.MaxEdge = readV3F1000(is); wall_bottom.MinEdge = readV3F1000(is); wall_bottom.MaxEdge = readV3F1000(is); wall_side.MinEdge = readV3F1000(is); wall_side.MaxEdge = readV3F1000(is); } else if (type == NODEBOX_CONNECTED) { #define READBOXES(box) { \ count = readU16(is); \ (box).reserve(count); \ while (count--) { \ v3f min = readV3F1000(is); \ v3f max = readV3F1000(is); \ (box).emplace_back(min, max); }; } u16 count; READBOXES(fixed); READBOXES(connect_top); READBOXES(connect_bottom); READBOXES(connect_front); READBOXES(connect_left); READBOXES(connect_back); READBOXES(connect_right); } } /* TileDef */ #define TILE_FLAG_BACKFACE_CULLING (1 << 0) #define TILE_FLAG_TILEABLE_HORIZONTAL (1 << 1) #define TILE_FLAG_TILEABLE_VERTICAL (1 << 2) #define TILE_FLAG_HAS_COLOR (1 << 3) #define TILE_FLAG_HAS_SCALE (1 << 4) #define TILE_FLAG_HAS_ALIGN_STYLE (1 << 5) void TileDef::serialize(std::ostream &os, u16 protocol_version) const { // protocol_version >= 36 u8 version = 6; writeU8(os, version); os << serializeString(name); animation.serialize(os, version); bool has_scale = scale > 0; u16 flags = 0; if (backface_culling) flags |= TILE_FLAG_BACKFACE_CULLING; if (tileable_horizontal) flags |= TILE_FLAG_TILEABLE_HORIZONTAL; if (tileable_vertical) flags |= TILE_FLAG_TILEABLE_VERTICAL; if (has_color) flags |= TILE_FLAG_HAS_COLOR; if (has_scale) flags |= TILE_FLAG_HAS_SCALE; if (align_style != ALIGN_STYLE_NODE) flags |= TILE_FLAG_HAS_ALIGN_STYLE; writeU16(os, flags); if (has_color) { writeU8(os, color.getRed()); writeU8(os, color.getGreen()); writeU8(os, color.getBlue()); } if (has_scale) writeU8(os, scale); if (align_style != ALIGN_STYLE_NODE) writeU8(os, align_style); } void TileDef::deSerialize(std::istream &is, u8 contentfeatures_version, NodeDrawType drawtype) { int version = readU8(is); if (version < 6) throw SerializationError("unsupported TileDef version"); name = deSerializeString(is); animation.deSerialize(is, version); u16 flags = readU16(is); backface_culling = flags & TILE_FLAG_BACKFACE_CULLING; tileable_horizontal = flags & TILE_FLAG_TILEABLE_HORIZONTAL; tileable_vertical = flags & TILE_FLAG_TILEABLE_VERTICAL; has_color = flags & TILE_FLAG_HAS_COLOR; bool has_scale = flags & TILE_FLAG_HAS_SCALE; bool has_align_style = flags & TILE_FLAG_HAS_ALIGN_STYLE; if (has_color) { color.setRed(readU8(is)); color.setGreen(readU8(is)); color.setBlue(readU8(is)); } scale = has_scale ? readU8(is) : 0; if (has_align_style) align_style = static_cast<AlignStyle>(readU8(is)); else align_style = ALIGN_STYLE_NODE; } /* SimpleSoundSpec serialization */ static void serializeSimpleSoundSpec(const SimpleSoundSpec &ss, std::ostream &os, u8 version) { os<<serializeString(ss.name); writeF1000(os, ss.gain); writeF1000(os, ss.pitch); } static void deSerializeSimpleSoundSpec(SimpleSoundSpec &ss, std::istream &is, u8 version) { ss.name = deSerializeString(is); ss.gain = readF1000(is); ss.pitch = readF1000(is); } void TextureSettings::readSettings() { connected_glass = g_settings->getBool("connected_glass"); opaque_water = g_settings->getBool("opaque_water"); bool enable_shaders = g_settings->getBool("enable_shaders"); bool enable_bumpmapping = g_settings->getBool("enable_bumpmapping"); bool enable_parallax_occlusion = g_settings->getBool("enable_parallax_occlusion"); bool smooth_lighting = g_settings->getBool("smooth_lighting"); enable_mesh_cache = g_settings->getBool("enable_mesh_cache"); enable_minimap = g_settings->getBool("enable_minimap"); node_texture_size = g_settings->getU16("texture_min_size"); std::string leaves_style_str = g_settings->get("leaves_style"); std::string world_aligned_mode_str = g_settings->get("world_aligned_mode"); std::string autoscale_mode_str = g_settings->get("autoscale_mode"); // Mesh cache is not supported in combination with smooth lighting if (smooth_lighting) enable_mesh_cache = false; use_normal_texture = enable_shaders && (enable_bumpmapping || enable_parallax_occlusion); if (leaves_style_str == "fancy") { leaves_style = LEAVES_FANCY; } else if (leaves_style_str == "simple") { leaves_style = LEAVES_SIMPLE; } else { leaves_style = LEAVES_OPAQUE; } if (world_aligned_mode_str == "enable") world_aligned_mode = WORLDALIGN_ENABLE; else if (world_aligned_mode_str == "force_solid") world_aligned_mode = WORLDALIGN_FORCE; else if (world_aligned_mode_str == "force_nodebox") world_aligned_mode = WORLDALIGN_FORCE_NODEBOX; else world_aligned_mode = WORLDALIGN_DISABLE; if (autoscale_mode_str == "enable") autoscale_mode = AUTOSCALE_ENABLE; else if (autoscale_mode_str == "force") autoscale_mode = AUTOSCALE_FORCE; else autoscale_mode = AUTOSCALE_DISABLE; } /* ContentFeatures */ ContentFeatures::ContentFeatures() { reset(); } void ContentFeatures::reset() { /* Cached stuff */ #ifndef SERVER solidness = 2; visual_solidness = 0; backface_culling = true; #endif has_on_construct = false; has_on_destruct = false; has_after_destruct = false; /* Actual data NOTE: Most of this is always overridden by the default values given in builtin.lua */ name = ""; groups.clear(); // Unknown nodes can be dug groups["dig_immediate"] = 2; drawtype = NDT_NORMAL; mesh = ""; #ifndef SERVER for (auto &i : mesh_ptr) i = NULL; minimap_color = video::SColor(0, 0, 0, 0); #endif visual_scale = 1.0; for (auto &i : tiledef) i = TileDef(); for (auto &j : tiledef_special) j = TileDef(); alpha = 255; post_effect_color = video::SColor(0, 0, 0, 0); param_type = CPT_NONE; param_type_2 = CPT2_NONE; is_ground_content = false; light_propagates = false; sunlight_propagates = false; walkable = true; pointable = true; diggable = true; climbable = false; buildable_to = false; floodable = false; rightclickable = true; leveled = 0; liquid_type = LIQUID_NONE; liquid_alternative_flowing = ""; liquid_alternative_source = ""; liquid_viscosity = 0; liquid_renewable = true; liquid_range = LIQUID_LEVEL_MAX+1; drowning = 0; light_source = 0; damage_per_second = 0; node_box = NodeBox(); selection_box = NodeBox(); collision_box = NodeBox(); waving = 0; legacy_facedir_simple = false; legacy_wallmounted = false; sound_footstep = SimpleSoundSpec(); sound_dig = SimpleSoundSpec("__group"); sound_dug = SimpleSoundSpec(); connects_to.clear(); connects_to_ids.clear(); connect_sides = 0; color = video::SColor(0xFFFFFFFF); palette_name = ""; palette = NULL; node_dig_prediction = "air"; } void ContentFeatures::serialize(std::ostream &os, u16 protocol_version) const { // protocol_version >= 36 u8 version = 12; writeU8(os, version); // general os << serializeString(name); writeU16(os, groups.size()); for (const auto &group : groups) { os << serializeString(group.first); writeS16(os, group.second); } writeU8(os, param_type); writeU8(os, param_type_2); // visual writeU8(os, drawtype); os << serializeString(mesh); writeF1000(os, visual_scale); writeU8(os, 6); for (const TileDef &td : tiledef) td.serialize(os, protocol_version); for (const TileDef &td : tiledef_overlay) td.serialize(os, protocol_version); writeU8(os, CF_SPECIAL_COUNT); for (const TileDef &td : tiledef_special) { td.serialize(os, protocol_version); } writeU8(os, alpha); writeU8(os, color.getRed()); writeU8(os, color.getGreen()); writeU8(os, color.getBlue()); os << serializeString(palette_name); writeU8(os, waving); writeU8(os, connect_sides); writeU16(os, connects_to_ids.size()); for (u16 connects_to_id : connects_to_ids) writeU16(os, connects_to_id); writeU8(os, post_effect_color.getAlpha()); writeU8(os, post_effect_color.getRed()); writeU8(os, post_effect_color.getGreen()); writeU8(os, post_effect_color.getBlue()); writeU8(os, leveled); // lighting writeU8(os, light_propagates); writeU8(os, sunlight_propagates); writeU8(os, light_source); // map generation writeU8(os, is_ground_content); // interaction writeU8(os, walkable); writeU8(os, pointable); writeU8(os, diggable); writeU8(os, climbable); writeU8(os, buildable_to); writeU8(os, rightclickable); writeU32(os, damage_per_second); // liquid writeU8(os, liquid_type); os << serializeString(liquid_alternative_flowing); os << serializeString(liquid_alternative_source); writeU8(os, liquid_viscosity); writeU8(os, liquid_renewable); writeU8(os, liquid_range); writeU8(os, drowning); writeU8(os, floodable); // node boxes node_box.serialize(os, protocol_version); selection_box.serialize(os, protocol_version); collision_box.serialize(os, protocol_version); // sound serializeSimpleSoundSpec(sound_footstep, os, version); serializeSimpleSoundSpec(sound_dig, os, version); serializeSimpleSoundSpec(sound_dug, os, version); // legacy writeU8(os, legacy_facedir_simple); writeU8(os, legacy_wallmounted); os << serializeString(node_dig_prediction); } void ContentFeatures::correctAlpha(TileDef *tiles, int length) { // alpha == 0 means that the node is using texture alpha if (alpha == 0 || alpha == 255) return; for (int i = 0; i < length; i++) { if (tiles[i].name.empty()) continue; std::stringstream s; s << tiles[i].name << "^[noalpha^[opacity:" << ((int)alpha); tiles[i].name = s.str(); } } void ContentFeatures::deSerialize(std::istream &is) { // version detection int version = readU8(is); if (version < 12) throw SerializationError("unsupported ContentFeatures version"); // general name = deSerializeString(is); groups.clear(); u32 groups_size = readU16(is); for (u32 i = 0; i < groups_size; i++) { std::string name = deSerializeString(is); int value = readS16(is); groups[name] = value; } param_type = (enum ContentParamType) readU8(is); param_type_2 = (enum ContentParamType2) readU8(is); // visual drawtype = (enum NodeDrawType) readU8(is); mesh = deSerializeString(is); visual_scale = readF1000(is);


context:
space:
mode: