/* -*- LPC -*- */ /* * $Locker: ceres $ * $Id: languages.c,v 1.32 2003/02/19 08:35:25 ceres Exp ceres $ */ /** * The language handler. This will keep track of the info on languages * Each language can be a written language a spoken language and have * a garble object. *<p> * The function garble_say, garble_tell, garble_shout and * garble_written should be defined on the garbling object. * They should return the entire string to print. So if the * routine returns 0 nothing is printed. * * @author Pinkfish */ #include <language.h> #define L_NEW 512 #define REPLACEMENTS (["no1":"noone",\ "ne1":"anyone",\ "any1":"anyone",\ "u":"you",\ "r":"are", \ "NE1":"anyone",\ "U":"you",\ "R":"are", \ "ur":"you are",\ "teh":"the", \ "some1":"someone", \ "c":"see", \ "cing":"seeing",\ "sum1":"someone",\ "urs":"yours",\ "thier":"their", \ "pls":"please",\ "PLZ":"please",\ "plz":"please",\ "b4":"before", \ "tnx":"thanks"]) mapping languages; string search; void create() { languages = ([ "rabbit" : ({ L_SPOKEN|L_WRITTEN|L_DISTANCE|L_ALWAYS_SPEAK|L_NEW, "/std/languages/rabbit", 10 }), "general" : ({ L_SPOKEN|L_WRITTEN|L_DISTANCE|L_ALWAYS_SPEAK/*|L_NEW */, "/std/languages/general", 10 }), //"common" : ({ L_SPOKEN|L_WRITTEN|L_DISTANCE/*|L_NEW */, // "/std/languages/common", 10 }), "grunt" : ({ L_SPOKEN | L_ALWAYS_SPEAK, "/std/languages/grunt", 100 }), "wommon" : ({ L_WRITTEN|L_SPOKEN|L_DISTANCE|L_MAGIC, "/std/languages/wommon", 10 }), ]); search = "(" + implode(keys(REPLACEMENTS), "|") + ")"; } /* create() */ /** * Determine if the language is spoken. * * @param str the language name to test * @return 1 if the language is spoken, 0 if it is not */ int query_language_spoken(string str) { if (!languages[str]) return 0; return languages[str][0]&L_SPOKEN; } /* query_language_spoken() */ /** * Determine if the language is written. * * @param str the language name to test * @return 1 if the language is written, 0 if it is not */ int query_language_written(string str) { if (!languages[str]) return 0; return languages[str][0]&L_WRITTEN; } /* query_language_written() */ /** * Determine if the language is spoken. * Distance languages can be used with tell and shout. * * @param str the language name to test * @return 1 if it is distance language, 0 if it is not */ int query_language_distance(string str) { if (!languages[str]) return 0; return languages[str][0]&L_DISTANCE; } /* query_language_distance() */ /** * @ignore yes */ int query_language_new(string str) { if (!languages[str]) return 0; return languages[str][0]&L_NEW; } /* query_language_new() */ /** * Determine if it is a magical language. * A magical langage gets a function called on it's object whenever it * is read even if the person knows the language. It is also the language * spells are written in. * * @param str the language to test * @return 1 if it is magical, 0 if it is not */ int query_language_magic(string str) { if (!languages[str]) return 0; return languages[str][0]&L_MAGIC; } /* query_language_magic() */ /** * The size of the language. Some languages have bigger letters * and stuff than others. * * @param str the language to get the size of * @return the size of each letter */ int query_language_size(string str) { if (!languages[str]) return 0; return languages[str][2]; } /* query_language_size() */ /** * Determine if the language is always able to be spoken. * * @param str the language name to test * @return 1 if the language is spoken, 0 if it is not */ int query_language_always_spoken(string str) { if (!languages[str]) return 0; return languages[str][0]&L_ALWAYS_SPEAK; } /* query_language_spoken() */ /* This is called to resize the text if it doesnt fit... */ /** * @ignore yes */ mixed squidge_text(string lang, mixed str, int size) { if (!languages[lang]) return 0; /* Don't add it... */ if (!(languages[lang][0]&L_MAGIC)) return str[0..(size/languages[lang][2])]; return (mixed)languages[lang][1]->squidge_text(str, size); } /* squish_text() */ /* Should not really allow this... int add_language(string name, int flags, mixed ob, int size) { languages[name] = ({ flags, ob, size }); } * add_language() */ /** * Return all the flags for the language. * * @param name the language to get the flags of * @return all the flags * @see /include/language.h */ int query_flags(string name) { if (!languages[name]) return 0; return languages[name][0]; } /* query_flags() */ /** * Figure out the garble object. This returns the garble object for the * language. The garble object is used to modify the text so that * player does not see plain text if they do not know the language. * * @param name the language to get the garble object for * @return the garble object */ string query_garble_object(string name) { if (!languages[name]) return 0; return languages[name][1]; } /* query_garble_object() */ /** * Names of all the languages. * @return the names of all the languages */ string *query_languages() { return m_indices(languages); } /* query_languages() */ /** * Determine if this is a language. * @return 1 if it is a language, 0 if it s not * @param str the language to check */ int test_language(string str) { return pointerp(languages[str]); } /* test_language() */ /** * The skill for the spoken language. This gets the skill name in the skill * tree for the spoken part of the language. * @param lang the language to get the skill of * @return the skill name */ string query_language_spoken_skill(string lang) { return LANGUAGE_SKILL_START + replace(lang, " ", "_") + "." + SPOKEN_SKILL; } /* query_language_spoken_skill() */ /** * The skill for the written language. This gets the skill name in the skill * tree for the written part of the language. * @param lang the language to get the skill of * @return the skill name */ string query_language_written_skill(string lang) { return LANGUAGE_SKILL_START + replace(lang, " ", "_") + "." + WRITTEN_SKILL; } /* query_language_written_skill() */ /** * This garbles a say. Called from the events class to garble the text * that players see. This looks up the garble object and calls the * correct function on it. The returned array contains the * garbled start and message. * * @param lang the language spoken in * @param start the start bit * @param mess the message itself * @param player the player hearing * @param from the player speaking * @param type 'say', 'tell', 'shout' etc * @return an array <code>({ start, mess })</code> */ mixed garble_say(string lang, string start, string mess, object player, object from, string type) { string garble_ob; if (query_language_new(lang)) { garble_ob = query_garble_object(lang); if (living (from) && garble_ob) { return garble_ob->garble_say(start, mess, player, from, type, query_language_spoken_skill(lang), type == SHOUT_TYPE); } } else { if (player->query_skill(query_language_spoken_skill(lang)) < 99) { garble_ob = query_garble_object(lang); if(garble_ob) return garble_ob->garble_say(start, mess, player, type); else debug_printf("Error, %s has no garble object.", lang); } } return ({ start, mess }); } /* garble_say() */ /** * Garble written text. This is the same as garble_say, but it works on * written text. * * @param lang the language written in * @param text the text which has been written * @param thing the thing which is written on * @param player the player doing the reading * @return the garbled text as a string */ string garble_text(string lang, mixed text, object thing, object player ) { string garble_ob; if (functionp(text)) { text = evaluate(text); } if (query_language_new(lang)) { garble_ob = query_garble_object(lang); if (garble_ob) { return garble_ob->garble_text(text, thing, player, query_language_written_skill(lang)); } } else { if (player->query_skill(query_language_written_skill(lang)) < 99) { garble_ob = query_garble_object(lang); if( !garble_ob ) return "You do not recognise the language.\n"; else return garble_ob->garble_text(text, thing, player); } if (query_language_magic(lang)) { garble_ob = query_garble_object(lang); return garble_ob->magical_text(text, thing, player); } return text; } if (query_language_magic(lang)) return 0; return "Text written in " + lang + " could not have been written. " "There are " "broken bits of letters scattered over the page, looks like " "someone had a bad game of scrabble.\n"; } /* garble_text() */ /** * Remove "ne1" and suchlike */ string do_replacements(string mess) { string *bits, name, value; mixed *tmp; int index, i, add_space; // This one's a little different so it's done on its own. mess = replace(mess, ({"ne1 no ", "anyone know "})); // First check to see if the sentance contains a possible replacement. if(!regexp(mess, search)) return mess; /* * We have a possible so explode the line into words and check each * replacement against each word. If there's a match then replace. */ if(mess[<1] == ' ') add_space = 1; bits = explode(mess, " "); foreach(name, value in REPLACEMENTS) { tmp = regexp(bits, "(^|[^A-Za-z0-9\\\\./_&-]+)"+name+"($|[^A-Za-z0-9\\./&_-]+)", 1); if(sizeof(tmp)) { for(i=0; i<sizeof(tmp); i+=2) { index = tmp[i+1]-1; bits[index] = replace(bits[index], name, value); } } } return implode(bits, " ") + (add_space ? " " : ""); } string fix_shorthand(string mess) { string pre, mid, post, res; if (!stringp(mess)) { return ""; } res = ""; while(sscanf(mess, "%s'%s'%s", pre, mid, post) == 3) { res += do_replacements(pre) + "'" + mid; mess = "'" + post; } res += do_replacements(mess); return res; }