mirror of
https://github.com/CHOMPStation2/CHOMPStation2.git
synced 2025-12-10 10:12:45 +00:00
283 lines
11 KiB
Plaintext
283 lines
11 KiB
Plaintext
/mob/proc/say(var/message, var/datum/language/speaking = null, var/whispering = 0)
|
|
return
|
|
|
|
/mob/verb/whisper(message as text)
|
|
set name = "Whisper"
|
|
set hidden = 1
|
|
if(forced_psay)
|
|
psay(message)
|
|
return
|
|
|
|
say(message,whispering=1)
|
|
|
|
/mob/verb/say_verb(message as text)
|
|
set name = "Say"
|
|
set hidden = 1
|
|
set instant = TRUE
|
|
|
|
if(forced_psay)
|
|
psay(message)
|
|
return
|
|
|
|
client?.stop_thinking()
|
|
//queue this message because verbs are scheduled to process after SendMaps in the tick and speech is pretty expensive when it happens.
|
|
//by queuing this for next tick the mc can compensate for its cost instead of having speech delay the start of the next tick
|
|
if(message)
|
|
QUEUE_OR_CALL_VERB_FOR(VERB_CALLBACK(src, TYPE_PROC_REF(/mob, say), message), SSspeech_controller)
|
|
|
|
/mob/verb/me_verb(message as message)
|
|
set name = "Me"
|
|
set desc = "Emote to nearby people (and your pred/prey)"
|
|
set hidden = 1
|
|
|
|
if(forced_psay)
|
|
pme(message)
|
|
return
|
|
|
|
if(muffled)
|
|
return me_verb_subtle(message)
|
|
if(autowhisper)
|
|
return me_verb_subtle(message)
|
|
message = sanitize_or_reflect(message,src) //Reflect too-long messages (within reason)
|
|
|
|
client?.stop_thinking()
|
|
if(use_me)
|
|
custom_emote(emote_type, message)
|
|
else
|
|
emote(message)
|
|
|
|
/mob/proc/say_dead(var/message)
|
|
if(!client)
|
|
return // Clientless mobs shouldn't be trying to talk in deadchat.
|
|
|
|
if(!client.holder)
|
|
if(!CONFIG_GET(flag/dsay_allowed))
|
|
to_chat(src, span_danger("Deadchat is globally muted."))
|
|
return
|
|
|
|
if(!client?.prefs?.read_preference(/datum/preference/toggle/show_dsay))
|
|
to_chat(src, span_danger("You have deadchat muted."))
|
|
return
|
|
|
|
message = encode_html_emphasis(message)
|
|
|
|
say_dead_direct("[pick("complains","moans","whines","laments","blubbers")], " + span_message("\"[message]\""), src)
|
|
|
|
/mob/proc/say_understands(var/mob/other, var/datum/language/speaking = null)
|
|
if(stat == DEAD)
|
|
return TRUE
|
|
|
|
//Universal speak makes everything understandable, for obvious reasons.
|
|
else if(universal_speak || universal_understand)
|
|
return TRUE
|
|
|
|
if(isliving(src))
|
|
var/mob/living/L = src
|
|
if(isbelly(L.loc) && L.absorbed)
|
|
var/mob/living/P = L.loc.loc
|
|
if(P.say_understands(other, speaking))
|
|
return TRUE
|
|
|
|
//Languages are handled after.
|
|
if(!speaking)
|
|
if(!other)
|
|
return TRUE
|
|
if(other.universal_speak)
|
|
return TRUE
|
|
if(isAI(src) && ispAI(other))
|
|
return TRUE
|
|
if(istype(other, type) || istype(src, other.type))
|
|
return TRUE
|
|
return FALSE
|
|
|
|
if(speaking.flags & INNATE)
|
|
return TRUE
|
|
|
|
//non-verbal languages are garbled if you can't see the speaker. Yes, this includes if they are inside a closet.
|
|
if(speaking.flags & NONVERBAL)
|
|
if(sdisabilities & BLIND || blinded)
|
|
return FALSE
|
|
if(!other)
|
|
return FALSE
|
|
// Fixes seeing non-verbal languages while being held
|
|
if(istype(other.loc, /obj/item/holder))
|
|
if(istype(src.loc, /obj/item/holder))
|
|
if(!(other.loc in view(src.loc.loc)))
|
|
return FALSE
|
|
else if(!(other.loc in view(src)))
|
|
return FALSE
|
|
else if(istype(src.loc, /obj/item/holder))
|
|
if((!other) in view(src.loc.loc))
|
|
return FALSE
|
|
else if((!other) in view(src))
|
|
return FALSE
|
|
|
|
//Language check.
|
|
for(var/datum/language/L in languages)
|
|
if(speaking.name == L.name)
|
|
return TRUE
|
|
|
|
return FALSE
|
|
|
|
/mob/proc/say_quote(var/message, var/datum/language/speaking = null)
|
|
var/verb = "says"
|
|
var/ending = copytext(message, length(message))
|
|
|
|
if(speaking)
|
|
verb = speaking.get_spoken_verb(ending)
|
|
else
|
|
if(ending == "!")
|
|
verb = pick("exclaims", "shouts", "yells")
|
|
else if(ending == "?")
|
|
verb = "asks"
|
|
return verb
|
|
|
|
/mob/proc/get_ear()
|
|
// returns an atom representing a location on the map from which this
|
|
// mob can hear things
|
|
|
|
// should be overloaded for all mobs whose "ear" is separate from their "mob"
|
|
|
|
return get_turf(src)
|
|
|
|
/proc/say_test(var/text)
|
|
var/ending = copytext(text, length(text))
|
|
if(ending == "?")
|
|
return "1"
|
|
else if(ending == "!")
|
|
return "2"
|
|
return "0"
|
|
|
|
//parses the message mode code (e.g. :h, :w) from text, such as that supplied to say.
|
|
//returns the message mode string or null for no message mode.
|
|
//standard mode is the mode returned for the special ';' radio code.
|
|
/mob/proc/parse_message_mode(var/message, var/standard_mode = "headset")
|
|
if(length(message) >= 1 && copytext(message, 1, 2) == ";")
|
|
return standard_mode
|
|
|
|
if(length(message) >= 2)
|
|
var/channel_prefix = copytext(message, 1, 3)
|
|
return department_radio_keys[channel_prefix]
|
|
|
|
return null
|
|
|
|
/datum/multilingual_say_piece
|
|
var/datum/language/speaking = null
|
|
var/message = ""
|
|
|
|
/datum/multilingual_say_piece/New(datum/language/new_speaking, new_message)
|
|
. = ..()
|
|
speaking = new_speaking
|
|
if(new_message)
|
|
message = new_message
|
|
|
|
/mob/proc/find_valid_prefixes(message)
|
|
var/list/prefixes = list() // [["Common", start, end], ["Gutter", start, end]]
|
|
for(var/i in 1 to length(message))
|
|
// This grabs 3 character substrings, to allow for up to 1 prefix, 1 letter language key, and one post-key character to more strictly control where the language breaks happen
|
|
var/selection = trim_right(copytext(message, i, i + 3)) // We use uppercase keys to avoid Polaris key duplication, but this had lowertext() in it
|
|
// The first character in the selection will always be the prefix (if this is a valid language invocation)
|
|
var/prefix = copytext(selection, 1, 2)
|
|
var/language_key = copytext(selection, 2, 3)
|
|
if(is_language_prefix(prefix))
|
|
// Okay, we're definitely now trying to invoke a language (probably)
|
|
// This "[]" is probably unnecessary but BYOND will runtime if a number is used
|
|
var/datum/language/L = GLOB.language_keys["[language_key]"]
|
|
if((language_key in language_keys) && language_keys[language_key])
|
|
L = language_keys[language_key]
|
|
|
|
// MULTILINGUAL_SPACE enforces a space after the language key
|
|
if(client && (client.prefs.multilingual_mode == MULTILINGUAL_SPACE) && (text2ascii(copytext(selection, 3, 4)) != 32)) // If we're looking for a space and we don't find one
|
|
continue
|
|
|
|
// MULTILINGUAL_DOUBLE_DELIMITER enforces a delimiter (valid prefix) after the language key
|
|
if(client && (client.prefs.multilingual_mode == MULTILINGUAL_DOUBLE_DELIMITER) && !is_language_prefix(copytext(selection, 3, 4)))
|
|
continue
|
|
|
|
if(client && (client.prefs.multilingual_mode in list(MULTILINGUAL_DEFAULT)))
|
|
selection = copytext(selection, 1, 3) // These modes only use two characters, not three
|
|
|
|
// It's kinda silly that we have to check L != null and this isn't done for us by can_speak (it runtimes instead), but w/e
|
|
if(L && can_speak(L))
|
|
// So we have a valid language invocation, and we can speak that language, let's make a piece for it
|
|
// This language will be the language until the next prefixes[] index, or the end of the message if there are none.
|
|
prefixes[++prefixes.len] = list(L, i, i + length(selection))
|
|
else if(L)
|
|
// We found a valid language, but they can't speak it. Let's make them speak gibberish instead.
|
|
prefixes[++prefixes.len] = list(GLOB.all_languages[LANGUAGE_GIBBERISH], i, i + length(selection))
|
|
continue
|
|
if(i == 1)
|
|
// This covers the case of "no prefixes in use."
|
|
prefixes[++prefixes.len] = list(get_default_language(), i, i)
|
|
|
|
// If multilingualism is disabled, then after the first pass we're guaranteed to have either found a language key at the start, or else there isn't one and we're using the default for the whole message
|
|
if(client && (client.prefs.multilingual_mode == MULTILINGUAL_OFF))
|
|
break
|
|
|
|
return prefixes
|
|
|
|
/mob/proc/strip_prefixes(message, mob/prefixer = null)
|
|
. = ""
|
|
var/last_index = 1
|
|
for(var/i in 1 to length(message))
|
|
var/selection = trim_right(lowertext(copytext(message, i, i + 2)))
|
|
// The first character in the selection will always be the prefix (if this is a valid language invocation)
|
|
var/prefix = copytext(selection, 1, 2)
|
|
var/language_key = copytext(selection, 2, 3)
|
|
if(is_language_prefix(prefix))
|
|
var/datum/language/L = GLOB.language_keys["[language_key]"]
|
|
if(L)
|
|
. += copytext(message, last_index, i)
|
|
last_index = i + 2
|
|
if(i + 1 > length(message))
|
|
. += copytext(message, last_index)
|
|
|
|
// this returns a structured message with language sections
|
|
// list(/datum/multilingual_say_piece(common, "hi"), /datum/multilingual_say_piece(farwa, "squik"), /datum/multilingual_say_piece(common, "meow!"))
|
|
/mob/proc/parse_languages(message)
|
|
. = list()
|
|
|
|
// Noise language is a snowflake.
|
|
if(copytext(message, 1, 2) == "!" && length(message) > 1)
|
|
// Note that list() here is intended
|
|
// Returning a raw /datum/multilingual_say_piece is supported, but only for hivemind languages
|
|
// What we actually want is a normal say piece that's all noise lang
|
|
return list(new /datum/multilingual_say_piece(GLOB.all_languages["Noise"], trim(strip_prefixes(copytext(message, 2)))))
|
|
|
|
// Scan the message for prefixes
|
|
var/list/prefix_locations = find_valid_prefixes(message)
|
|
if(!LAZYLEN(prefix_locations)) // There are no prefixes... or at least, no _valid_ prefixes.
|
|
. += new /datum/multilingual_say_piece(get_default_language(), trim(strip_prefixes(message))) // So we'll just strip those pesky things and still make the message.
|
|
|
|
for(var/i in 1 to length(prefix_locations))
|
|
var/current = prefix_locations[i] // ["Common", start, end]
|
|
|
|
// There are a few things that will make us want to ignore all other languages in - namely, HIVEMIND languages.
|
|
var/datum/language/L = current[1]
|
|
if(L && (L.flags & HIVEMIND || L.flags & SIGNLANG || L.flags & INAUDIBLE))
|
|
return new /datum/multilingual_say_piece(L, trim(sanitize(strip_prefixes(message))))
|
|
|
|
if(i + 1 > length(prefix_locations)) // We are out of lookaheads, that means the rest of the message is in cur lang
|
|
var/spoke_message = sanitize(handle_autohiss(trim(copytext(message, current[3])), L))
|
|
. += new /datum/multilingual_say_piece(current[1], spoke_message)
|
|
else
|
|
var/next = prefix_locations[i + 1] // We look ahead at the next message to see where we need to stop.
|
|
var/spoke_message = sanitize(handle_autohiss(trim(copytext(message, current[3], next[2])), L))
|
|
. += new /datum/multilingual_say_piece(current[1], spoke_message)
|
|
|
|
/* These are here purely because it would be hell to try to convert everything over to using the multi-lingual system at once */
|
|
/proc/message_to_multilingual(message, datum/language/speaking = null)
|
|
. = list(new /datum/multilingual_say_piece(speaking, message))
|
|
|
|
/proc/multilingual_to_message(list/message_pieces, var/requires_machine_understands = FALSE, var/with_capitalization = FALSE)
|
|
. = ""
|
|
for(var/datum/multilingual_say_piece/S in message_pieces)
|
|
var/message_to_append = S.message
|
|
if(S.speaking)
|
|
if(with_capitalization)
|
|
message_to_append = S.speaking.format_message_plain(S.message)
|
|
if(requires_machine_understands && !S.speaking.machine_understands)
|
|
message_to_append = S.speaking.scramble(S.message)
|
|
. += message_to_append + " "
|
|
. = trim_right(.)
|