dsrc/sku.0/sys.server/compiled/game/script/library/chat.scriptlib

include library.utils;
include library.space_utils;
/* --------------------------------------------------
 * MOOD CONSTS:
 * --------------------------------------------------*/
const string MOOD_NONE = "none";
const string MOOD_ABSENTMINDED = "absentminded";
const string MOOD_AMAZED = "amazed";
const string MOOD_AMUSED = "amused";
const string MOOD_ANGRY = "angry";
const string MOOD_APPROVING = "approving";
const string MOOD_BITTER = "bitter";
const string MOOD_BLOODTHIRSTY = "bloodthirsty";
const string MOOD_BORED = "bored";
const string MOOD_BRAVE = "brave";
const string MOOD_CALLOUS = "callous";
const string MOOD_CAREFUL = "careful";
const string MOOD_CARELESS = "careless";
const string MOOD_CASUAL = "casual";
const string MOOD_CLINICAL = "clinical";
const string MOOD_COCKY = "cocky";
const string MOOD_COLD = "cold";
const string MOOD_COMPASSIONATE = "compassionate";
const string MOOD_CONDESCENDING = "condescending";
const string MOOD_CONFIDENT = "confident";
const string MOOD_CONFUSED = "confused";
const string MOOD_CONTENT = "content";
const string MOOD_COURTLY = "courtly";
const string MOOD_COY = "coy";
const string MOOD_CRUDE = "crude";
const string MOOD_CRUEL = "cruel";
const string MOOD_CURIOUS = "curious";
const string MOOD_CYNICAL = "cynical";
const string MOOD_DEFENSIVE = "defensive";
const string MOOD_DEPRESSED = "depressed";
const string MOOD_DEVIOUS = "devious";
const string MOOD_DIMWITTED = "dimwitted";
const string MOOD_DISAPPOINTED = "disappointed";
const string MOOD_DISCREET = "discreet";
const string MOOD_DISGRUNTLED = "disgruntled";
const string MOOD_DISGUSTED = "disgusted";
const string MOOD_DISMAYED = "dismayed";
const string MOOD_DISORIENTED = "disoriented";
const string MOOD_DISTRACTED = "distracted";
const string MOOD_DOUBTFUL = "doubtful";
const string MOOD_DRAMATIC = "dramatic";
const string MOOD_DREAMY = "dreamy";
const string MOOD_DRUNK = "drunk";
const string MOOD_EARNEST = "earnest";
const string MOOD_ECSTATIC = "ecstatic";
const string MOOD_EMBARRASSED = "embarrassed";
const string MOOD_EMPHATIC = "emphatic";
const string MOOD_ENCOURAGING = "encouraging";
const string MOOD_ENTHUSIASTIC = "enthusiastic";
const string MOOD_EVIL = "evil";
const string MOOD_EXASPERATED = "exasperated";
const string MOOD_EXUBERANT = "exuberant";
const string MOOD_FANATICAL = "fanatical";
const string MOOD_FORGIVE = "forgive";
const string MOOD_FRUSTRATED = "frustrated";
const string MOOD_GUILTY = "guilty";
const string MOOD_HAPPY = "happy";
const string MOOD_HONEST = "honest";
const string MOOD_HOPEFUL = "hopeful";
const string MOOD_HOPELESS = "hopeless";
const string MOOD_HUMBLE = "humble";
const string MOOD_HYSTERICAL = "hysterical";
const string MOOD_IMPLORING = "imploring";
const string MOOD_INDIFFERENT = "indifferent";
const string MOOD_INDIGNANT = "indignant";
const string MOOD_INTERESTED = "interested";
const string MOOD_JEALOUS = "jealous";
const string MOOD_JOYFUL = "joyful";
const string MOOD_LOFTY = "lofty";
const string MOOD_LOUD = "loud";
const string MOOD_LOVING = "loving";
const string MOOD_LUSTFUL = "lustful";
const string MOOD_MEAN = "mean";
const string MOOD_MISCHIEVOUS = "mischievous";
const string MOOD_NERVOUS = "nervous";
const string MOOD_NEUTRAL = "neutral";
const string MOOD_OFFENDED = "offended";
const string MOOD_OPTIMISTIC = "optimistic";
const string MOOD_PEDANTIC = "pedantic";
const string MOOD_PESSIMISTIC = "pessimistic";
const string MOOD_PETULANT = "petulant";
const string MOOD_PHILOSOPHICAL = "philosophical";
const string MOOD_PITYING = "pitying";
const string MOOD_PLAYFUL = "playful";
const string MOOD_POLITE = "polite";
const string MOOD_POMPOUS = "pompous";
const string MOOD_PROUD = "proud";
const string MOOD_PROVOCATIVE = "provocative";
const string MOOD_PUZZLED = "puzzled";
const string MOOD_REGRETFUL = "regretful";
const string MOOD_RELIEVED = "relieved";
const string MOOD_RELUCTANT = "reluctant";
const string MOOD_RESIGNED = "resigned";
const string MOOD_RESPECTFUL = "respectful";
const string MOOD_ROMANTIC = "romantic";
const string MOOD_RUDE = "rude";
const string MOOD_SAD = "sad";
const string MOOD_SARCASTIC = "sarcastic";
const string MOOD_SCARED = "scared";
const string MOOD_SCOLDING = "scolding";
const string MOOD_SCORNFUL = "scornful";
const string MOOD_SERIOUS = "serious";
const string MOOD_SHAMELESS = "shameless";
const string MOOD_SHOCKED = "shocked";
const string MOOD_SHY = "shy";
const string MOOD_SINCERE = "sincere";
const string MOOD_SLEEPY = "sleepy";
const string MOOD_SLY = "sly";
const string MOOD_SMUG = "smug";
const string MOOD_SNOBBY = "snobby";
const string MOOD_SORRY = "sorry";
const string MOOD_SPITEFUL = "spiteful";
const string MOOD_STUBBORN = "stubborn";
const string MOOD_SULLEN = "sullen";
const string MOOD_SUSPICIOUS = "suspicious";
const string MOOD_TAUNTING = "taunting";
const string MOOD_TERRIFIED = "terrified";
const string MOOD_THANKFUL = "thankful";
const string MOOD_THOUGHTFUL = "thoughtful";
const string MOOD_TOLERANT = "tolerant";
const string MOOD_UNCERTAIN = "uncertain";
const string MOOD_UNHAPPY = "unhappy";
const string MOOD_UNWILLING = "unwilling";
const string MOOD_WARM = "warm";
const string MOOD_WHINY = "whiny";
const string MOOD_WICKED = "wicked";
const string MOOD_WISTFUL = "wistful";
const string MOOD_WORRIED = "worried";
const string MOOD_TIRED = "tired";
const string MOOD_EXHAUSTED = "exhausted";
const string MOOD_FRIENDLY = "friendly";
const string MOOD_TIMID = "timid";
const string MOOD_LAZY = "lazy";
const string MOOD_SURPRISED = "surprised";
const string MOOD_INNOCENT = "innocent";
const string MOOD_WISE = "wise";
const string MOOD_YOUTHFUL = "youthful";
const string MOOD_ADVENTUROUS = "adventurous";
const string MOOD_ANNOYED = "annoyed";
const string MOOD_PERTURBED = "perturbed";
const string MOOD_SEDATE = "sedate";
const string MOOD_CALM = "calm";
const string MOOD_SUFFERING = "suffering";
const string MOOD_HUNGRY = "hungry";
const string MOOD_THIRSTY = "thirsty";
const string MOOD_ALERT = "alert";
const string MOOD_SHIFTY = "shifty";
const string MOOD_RELAXED = "relaxed";
const string MOOD_CROTCHETY = "crotchety";
const string MOOD_SURLY = "surly";
const string MOOD_PAINFUL = "painful";
const string MOOD_WOUNDED = "wounded";
const string MOOD_BUBBLY = "bubbly";
const string MOOD_HEROIC = "heroic";
const string MOOD_QUIET = "quiet";
const string MOOD_REMORSEFUL = "remorseful";
const string MOOD_GRUMPY = "grumpy";
const string MOOD_LOGICAL = "logical";
const string MOOD_EMOTIONAL = "emotional";
const string MOOD_TROUBLED = "troubled";
const string MOOD_PANICKED = "panicked";
const string MOOD_NICE = "nice";
const string MOOD_CHEERFUL = "cheerful";
const string MOOD_EMOTIONLESS = "emotionless";
const string MOOD_GLOOMY = "gloomy";
const string MOOD_AMBIVALENT = "ambivalent";
const string MOOD_ENVIOUS = "envious";
const string MOOD_VENGEFUL = "vengeful";
const string MOOD_FEARFUL = "fearful";
const string MOOD_ENRAGED = "enraged";
const string MOOD_SHEEPISH = "sheepish";
//const string MOOD_BELLIGERENT = "belligerent";
const string MOOD_OBNOXIOUS = "obnoxious";
const string MOOD_FASTIDIOUS = "fastidious";
const string MOOD_SQUEAMISH = "squeamish";
const string MOOD_DAINTY = "dainty";
const string MOOD_DIGNIFIED = "dignified";
const string MOOD_HAUGHTY = "haughty";
const string MOOD_OBSCURE = "obscure";
const string MOOD_GOOFY = "goofy";
const string MOOD_SILLY = "silly";
const string MOOD_DISDAINFUL = "disdainful";
const string MOOD_CONTEMPTUOUS = "contemptuous";
const string MOOD_DIPLOMATIC = "diplomatic";
const string MOOD_WARY = "wary";
const string MOOD_MALEVOLENT = "malevolent";
const string MOOD_HURRIED = "hurried";
const string MOOD_PATIENT = "patient";
const string MOOD_FIRM = "firm";

const string[] BADMOODS = {
			MOOD_ANGRY,
			MOOD_BITTER,
			MOOD_BLOODTHIRSTY,
			MOOD_CALLOUS,
			MOOD_COLD,
			MOOD_CONDESCENDING,
			MOOD_CRUDE,
			MOOD_CRUEL,
			MOOD_CYNICAL,
			MOOD_DEFENSIVE,
			MOOD_DEPRESSED,
			MOOD_DEVIOUS,
			MOOD_DISAPPOINTED,
			MOOD_DISGRUNTLED,
			MOOD_DISGUSTED,
			MOOD_DISMAYED,
			MOOD_DOUBTFUL,
			MOOD_EVIL,
			MOOD_EXASPERATED,
			MOOD_FRUSTRATED,
			MOOD_GUILTY,
			MOOD_HOPELESS,
			MOOD_INDIFFERENT,
			MOOD_INDIGNANT,
			MOOD_MEAN,
			MOOD_MISCHIEVOUS,
			MOOD_PESSIMISTIC,
			MOOD_PETULANT,
			MOOD_POMPOUS,
			MOOD_RESIGNED,
			MOOD_RUDE,
			MOOD_SAD,
			MOOD_SCOLDING,
			MOOD_SCORNFUL,
			MOOD_SMUG,
			MOOD_SNOBBY,
			MOOD_SPITEFUL,
			MOOD_SULLEN,
			MOOD_UNHAPPY,
			MOOD_UNWILLING,
			MOOD_WICKED,
			MOOD_WORRIED,
			MOOD_TIRED,
			MOOD_EXHAUSTED,
			MOOD_ANNOYED,
			MOOD_PERTURBED,
			MOOD_SUFFERING,
			MOOD_CROTCHETY,
			MOOD_SURLY,
			MOOD_GRUMPY,
			MOOD_EMOTIONLESS,
			MOOD_GLOOMY,
			MOOD_AMBIVALENT,
			MOOD_OBNOXIOUS,
			MOOD_DISDAINFUL,
			MOOD_CONTEMPTUOUS,
			MOOD_WARY,
			MOOD_MALEVOLENT
		};//bad moods

const string[] GOODMOODS = {
			MOOD_AMUSED,
			MOOD_APPROVING,
			MOOD_BRAVE,
			MOOD_CASUAL,
			MOOD_COMPASSIONATE,
			MOOD_CONTENT,
			MOOD_DISCREET,
			MOOD_DREAMY,
			MOOD_EARNEST,
			MOOD_ECSTATIC,
			MOOD_ENCOURAGING,
			MOOD_ENTHUSIASTIC,
			MOOD_EXUBERANT,
			MOOD_HAPPY,
			MOOD_INTERESTED,
			MOOD_JOYFUL,
			MOOD_LOFTY,
			MOOD_LOVING,
			MOOD_OPTIMISTIC,
			MOOD_PLAYFUL,
			MOOD_POLITE,
			MOOD_RELIEVED,
			MOOD_RESPECTFUL,
			MOOD_SINCERE,
			MOOD_THOUGHTFUL,
			MOOD_TOLERANT,
			MOOD_WARM,
			MOOD_FRIENDLY,
			MOOD_YOUTHFUL,
			MOOD_ADVENTUROUS,
			MOOD_CALM,
			MOOD_ALERT,
			MOOD_BUBBLY,
			MOOD_HEROIC,
			MOOD_NICE,
			MOOD_CHEERFUL,
			MOOD_DIGNIFIED,
			MOOD_PATIENT
		};//good moods

const string[] ANGRYMOODS = {
			MOOD_ANGRY,
			MOOD_BITTER,
			MOOD_BLOODTHIRSTY,
			MOOD_CALLOUS,
			MOOD_COCKY,
			MOOD_COLD,
			MOOD_CRUEL,
			MOOD_EVIL,
			MOOD_FANATICAL,
			MOOD_MEAN,
			MOOD_PETULANT,
			MOOD_RUDE,
			MOOD_SCORNFUL,
			MOOD_TAUNTING,
			MOOD_WICKED,
			MOOD_PERTURBED,
			MOOD_VENGEFUL,
			MOOD_ENRAGED,
			MOOD_OBNOXIOUS,
			MOOD_CONTEMPTUOUS,
			MOOD_MALEVOLENT
		};//angry moods

const string[] NEUTRALMOODS = {
			MOOD_NONE,
			MOOD_BORED,
			MOOD_CASUAL,
			MOOD_CONTENT,
			MOOD_INDIFFERENT,
			MOOD_NEUTRAL,
			MOOD_SERIOUS,
			MOOD_THOUGHTFUL,
			MOOD_INNOCENT,
			MOOD_SEDATE,
			MOOD_CALM,
			MOOD_RELAXED,
			MOOD_QUIET,
			MOOD_EMOTIONLESS,
			MOOD_FIRM
		};//neutralmoods

const string[] ALLMOODS = {
			MOOD_NONE,
			MOOD_ABSENTMINDED,
			MOOD_AMAZED,
			MOOD_AMUSED,
			MOOD_ANGRY,
			MOOD_APPROVING,
			MOOD_BITTER,
			MOOD_BLOODTHIRSTY,
			MOOD_BORED,
			MOOD_BRAVE,
			MOOD_CALLOUS,
			MOOD_CAREFUL,
			MOOD_CARELESS,
			MOOD_CASUAL,
			MOOD_CLINICAL,
			MOOD_COCKY,
			MOOD_COLD,
			MOOD_COMPASSIONATE,
			MOOD_CONDESCENDING,
			MOOD_CONFIDENT,
			MOOD_CONFUSED,
			MOOD_CONTENT,
			MOOD_COURTLY,
			MOOD_COY,
			MOOD_CRUDE,
			MOOD_CRUEL,
			MOOD_CURIOUS,
			MOOD_CYNICAL,
			MOOD_DEFENSIVE,
			MOOD_DEPRESSED,
			MOOD_DEVIOUS,
			MOOD_DIMWITTED,
			MOOD_DISAPPOINTED,
			MOOD_DISCREET,
			MOOD_DISGRUNTLED,
			MOOD_DISGUSTED,
			MOOD_DISMAYED,
			MOOD_DISORIENTED,
			MOOD_DISTRACTED,
			MOOD_DOUBTFUL,
			MOOD_DRAMATIC,
			MOOD_DREAMY,
			MOOD_DRUNK,
			MOOD_EARNEST,
			MOOD_ECSTATIC,
			MOOD_EMBARRASSED,
			MOOD_EMPHATIC,
			MOOD_ENCOURAGING,
			MOOD_ENTHUSIASTIC,
			MOOD_EVIL,
			MOOD_EXASPERATED,
			MOOD_EXUBERANT,
			MOOD_FANATICAL,
			MOOD_FORGIVE,
			MOOD_FRUSTRATED,
			MOOD_GUILTY,
			MOOD_HAPPY,
			MOOD_HONEST,
			MOOD_HOPEFUL,
			MOOD_HOPELESS,
			MOOD_HUMBLE,
			MOOD_HYSTERICAL,
			MOOD_IMPLORING,
			MOOD_INDIFFERENT,
			MOOD_INDIGNANT,
			MOOD_INTERESTED,
			MOOD_JEALOUS,
			MOOD_JOYFUL,
			MOOD_LOFTY,
			MOOD_LOUD,
			MOOD_LOVING,
			MOOD_LUSTFUL,
			MOOD_MEAN,
			MOOD_MISCHIEVOUS,
			MOOD_NERVOUS,
			MOOD_NEUTRAL,
			MOOD_OFFENDED,
			MOOD_OPTIMISTIC,
			MOOD_PEDANTIC,
			MOOD_PESSIMISTIC,
			MOOD_PETULANT,
			MOOD_PHILOSOPHICAL,
			MOOD_PITYING,
			MOOD_PLAYFUL,
			MOOD_POLITE,
			MOOD_POMPOUS,
			MOOD_PROUD,
			MOOD_PROVOCATIVE,
			MOOD_PUZZLED,
			MOOD_REGRETFUL,
			MOOD_RELIEVED,
			MOOD_RELUCTANT,
			MOOD_RESIGNED,
			MOOD_RESPECTFUL,
			MOOD_ROMANTIC,
			MOOD_RUDE,
			MOOD_SAD,
			MOOD_SARCASTIC,
			MOOD_SCARED,
			MOOD_SCOLDING,
			MOOD_SCORNFUL,
			MOOD_SERIOUS,
			MOOD_SHAMELESS,
			MOOD_SHOCKED,
			MOOD_SHY,
			MOOD_SINCERE,
			MOOD_SLEEPY,
			MOOD_SLY,
			MOOD_SMUG,
			MOOD_SNOBBY,
			MOOD_SORRY,
			MOOD_SPITEFUL,
			MOOD_STUBBORN,
			MOOD_SULLEN,
			MOOD_SUSPICIOUS,
			MOOD_TAUNTING,
			MOOD_TERRIFIED,
			MOOD_THANKFUL,
			MOOD_THOUGHTFUL,
			MOOD_TOLERANT,
			MOOD_UNCERTAIN,
			MOOD_UNHAPPY,
			MOOD_UNWILLING,
			MOOD_WARM,
			MOOD_WHINY,
			MOOD_WICKED,
			MOOD_WISTFUL,
			MOOD_WORRIED,
			MOOD_TIRED,
			MOOD_EXHAUSTED,
			MOOD_FRIENDLY,
			MOOD_TIMID,
			MOOD_LAZY,
			MOOD_SURPRISED,
			MOOD_INNOCENT,
			MOOD_WISE,
			MOOD_YOUTHFUL,
			MOOD_ADVENTUROUS,
			MOOD_ANNOYED,
			MOOD_PERTURBED,
			MOOD_SEDATE,
			MOOD_CALM,
			MOOD_SUFFERING,
			MOOD_HUNGRY,
			MOOD_THIRSTY,
			MOOD_ALERT,
			MOOD_SHIFTY,
			MOOD_RELAXED,
			MOOD_CROTCHETY,
			MOOD_SURLY,
			MOOD_PAINFUL,
			MOOD_WOUNDED,
			MOOD_BUBBLY,
			MOOD_HEROIC,
			MOOD_QUIET,
			MOOD_REMORSEFUL,
			MOOD_GRUMPY,
			MOOD_LOGICAL,
			MOOD_EMOTIONAL,
			MOOD_TROUBLED,
			MOOD_PANICKED,
			MOOD_NICE,
			MOOD_CHEERFUL,
			MOOD_EMOTIONLESS,
			MOOD_GLOOMY,
			MOOD_AMBIVALENT,
			MOOD_ENVIOUS,
			MOOD_VENGEFUL,
			MOOD_FEARFUL,
			MOOD_ENRAGED,
			MOOD_SHEEPISH,
			MOOD_OBNOXIOUS,
			MOOD_FASTIDIOUS,
			MOOD_SQUEAMISH,
			MOOD_DAINTY,
			MOOD_DIGNIFIED,
			MOOD_HAUGHTY,
			MOOD_OBSCURE,
			MOOD_GOOFY,
			MOOD_SILLY,
			MOOD_DISDAINFUL,
			MOOD_CONTEMPTUOUS,
			MOOD_DIPLOMATIC,
			MOOD_WARY,
			MOOD_MALEVOLENT,
			MOOD_HURRIED,
			MOOD_PATIENT,
			MOOD_FIRM
		};//all moods

/* --------------------------------------------------
 * CHAT-TYPE CONSTS:
 * --------------------------------------------------*/
const string CHAT_SAY = "say";
const string CHAT_INTONE = "intone";
const string CHAT_MUMBLE = "mumble";
const string CHAT_BABBLE = "babble";
const string CHAT_ASSERT = "assert";
const string CHAT_ADD = "add";
const string CHAT_ADMIT = "admit";
const string CHAT_ANSWER = "answer";
const string CHAT_CAROL = "carol";
const string CHAT_CHATTER = "chatter";
const string CHAT_COMPLAIN = "complain";
const string CHAT_COO = "coo";
const string CHAT_DECLARE = "declare";
const string CHAT_DEMAND = "demand";
const string CHAT_DESCRIBE = "describe";
const string CHAT_DRAWL = "drawl";
const string CHAT_DRONE = "drone";
const string CHAT_EXCLAIM = "exclaim";
const string CHAT_DECREE = "decree";
const string CHAT_EXPLAIN = "explain";
const string CHAT_HOWL = "howl";
const string CHAT_INDICATE = "indicate";
const string CHAT_MOAN = "moan";
const string CHAT_HUFF = "huff";
const string CHAT_PROCLAIM = "proclaim";
const string CHAT_NOTE = "note";
const string CHAT_PLEAD = "plead";
const string CHAT_BEG = "beg";
const string CHAT_PRATTLE = "prattle";
const string CHAT_TATTLE = "tattle";
const string CHAT_QUOTE = "quote";
const string CHAT_RAMBLE = "ramble";
const string CHAT_DRIVEL = "drivel";
const string CHAT_SING = "sing";
const string CHAT_REQUEST = "request";
const string CHAT_RETORT = "retort";
const string CHAT_SCREAM = "scream";
const string CHAT_STATE = "state";
const string CHAT_STUTTER = "stutter";
const string CHAT_THREATEN = "threaten";
const string CHAT_UTTER = "utter";
const string CHAT_WAIL = "wail";
const string CHAT_WHINE = "whine";
const string CHAT_PREACH = "preach";
const string CHAT_ARGUE = "argue";
const string CHAT_LISP = "lisp";
const string CHAT_RECITE = "recite";
const string CHAT_MOUTH = "mouth";
const string CHAT_COMMAND = "command";
const string CHAT_RAP = "rap";
const string CHAT_PROPHESIZE = "prophesize";
const string CHAT_GAB = "gab";
const string CHAT_GOSSIP = "gossip";
const string CHAT_PRONOUNCE = "pronounce";
const string CHAT_LECTURE = "lecture";
const string CHAT_BELLOW = "bellow";
const string CHAT_EULOGIZE = "eulogize";
const string CHAT_BLAB = "blab";
const string CHAT_VENT = "vent";
const string CHAT_DIVULGE = "divulge";
const string CHAT_CONFIDE = "confide";
const string CHAT_AVOW = "avow";
const string CHAT_VOW = "vow";
const string CHAT_CONFESS = "confess";
const string CHAT_BLURT = "blurt";
const string CHAT_INTERJECT = "interject";
const string CHAT_RIDDLE = "riddle";
const string CHAT_ANNOUNCE = "announce";
const string CHAT_FORETELL = "foretell";
const string CHAT_SLUR = "slur";
const string CHAT_BLEAT = "bleat";
const string CHAT_DISCLOSE = "disclose";
const string CHAT_HYPOTHESIZE = "hypothesize";
const string CHAT_SWEAR = "swear";
const string CHAT_PROMISE = "promise";
const string CHAT_PARROT = "parrot";
const string CHAT_BRAG = "brag";
const string CHAT_JAW = "jaw";
const string CHAT_JABBER = "jabber";
const string CHAT_CHAT = "chat";
const string CHAT_YACK = "yack";
const string CHAT_INQUIRE = "inquire";
const string CHAT_INTERRUPT = "interrupt";
const string CHAT_SUPPOSE = "suppose";
const string CHAT_JEST = "jest";
const string CHAT_YELP = "yelp";
const string CHAT_SHRILL = "shrill";
const string CHAT_BOAST = "boast";
const string CHAT_CONCEDE = "concede";
const string CHAT_CONCLUDE = "conclude";
const string CHAT_SURMISE = "surmise";
const string CHAT_THEORIZE = "theorize";
const string CHAT_CHANT = "chant";
const string CHAT_PROPOSE = "propose";
const string CHAT_RESPOND = "respond";
const string CHAT_DEBATE = "debate";
const string CHAT_MUSE = "muse";
const string CHAT_EMOTE = "emote";
const string CHAT_WHISPER = "whisper";
const string CHAT_YELL = "yell";
const string CHAT_SHOUT = "shout";

const string[] BADTYPES = {
			CHAT_SAY,
			CHAT_INTONE,
			CHAT_COMPLAIN,
			CHAT_HUFF,
			CHAT_VENT,
			CHAT_BLURT,
			CHAT_SWEAR
	};//bad types

const string[] GOODTYPES = {
			CHAT_SAY,
			CHAT_ASSERT,
			CHAT_DECLARE,
			CHAT_EXCLAIM,
			CHAT_PRATTLE,
			CHAT_STATE,
			CHAT_UTTER,
			CHAT_MOUTH,
			CHAT_GAB,
			CHAT_GOSSIP,
			CHAT_BLAB,
			CHAT_ANNOUNCE,
			CHAT_JAW,
			CHAT_JABBER,
			CHAT_CHAT,
			CHAT_YACK
	};//good types

const string[] ANGRYTYPES = {
			CHAT_SAY,
			CHAT_ASSERT,
			CHAT_DECLARE,
			CHAT_DEMAND,
			CHAT_EXCLAIM,
			CHAT_HOWL,
			CHAT_PROCLAIM,
			CHAT_SCREAM,
			CHAT_THREATEN,
			CHAT_COMMAND,
			CHAT_PRONOUNCE,
			CHAT_BELLOW,
			CHAT_VENT,
			CHAT_BLURT,
			CHAT_SWEAR,
			CHAT_YELP,
			CHAT_YELL,
			CHAT_SHOUT
	};//angry types

const string[] NEUTRALTYPES = {
			CHAT_SAY,
			CHAT_INTONE,
			CHAT_MUMBLE,
			CHAT_CHATTER,
			CHAT_DRONE,
			CHAT_INDICATE,
			CHAT_NOTE,
			CHAT_PRATTLE,
			CHAT_RAMBLE,
			CHAT_STATE,
			CHAT_UTTER,
			//CHAT_RAP,
			CHAT_GAB,
			CHAT_GOSSIP,
			CHAT_BLAB,
			CHAT_CHAT,
			CHAT_YACK
	};//neutral types

const string[] ALL_CHAT_TYPES = {
			CHAT_SAY,
			CHAT_INTONE,
			CHAT_MUMBLE,
			CHAT_BABBLE,
			CHAT_ASSERT,
			CHAT_ADD,
			CHAT_ADMIT,
			CHAT_ANSWER,
			CHAT_CAROL,
			CHAT_CHATTER,
			CHAT_COMPLAIN,
			CHAT_COO,
			CHAT_DECLARE,
			CHAT_DEMAND,
			CHAT_DESCRIBE,
			CHAT_DRAWL,
			CHAT_DRONE,
			CHAT_EXCLAIM,
			CHAT_DECREE,
			CHAT_EXPLAIN,
			CHAT_HOWL,
			CHAT_INDICATE,
			CHAT_MOAN,
			CHAT_HUFF,
			CHAT_PROCLAIM,
			CHAT_NOTE,
			CHAT_PLEAD,
			CHAT_BEG,
			CHAT_PRATTLE,
			CHAT_TATTLE,
			CHAT_QUOTE,
			CHAT_RAMBLE,
			CHAT_DRIVEL,
			CHAT_SING,
			CHAT_REQUEST,
			CHAT_RETORT,
			CHAT_SCREAM,
			CHAT_STATE,
			CHAT_STUTTER,
			CHAT_THREATEN,
			CHAT_UTTER,
			CHAT_WAIL,
			CHAT_WHINE,
			CHAT_PREACH,
			CHAT_ARGUE,
			CHAT_LISP,
			CHAT_RECITE,
			CHAT_MOUTH,
			CHAT_COMMAND,
			//CHAT_RAP,
			CHAT_PROPHESIZE,
			CHAT_GAB,
			CHAT_GOSSIP,
			CHAT_PRONOUNCE,
			CHAT_LECTURE,
			CHAT_BELLOW,
			CHAT_EULOGIZE,
			CHAT_BLAB,
			CHAT_VENT,
			CHAT_DIVULGE,
			CHAT_CONFIDE,
			CHAT_AVOW,
			CHAT_VOW,
			CHAT_CONFESS,
			CHAT_BLURT,
			CHAT_INTERJECT,
			CHAT_RIDDLE,
			CHAT_ANNOUNCE,
			CHAT_FORETELL,
			CHAT_SLUR,
			CHAT_BLEAT,
			CHAT_DISCLOSE,
			CHAT_HYPOTHESIZE,
			CHAT_SWEAR,
			CHAT_PROMISE,
			CHAT_PARROT,
			CHAT_BRAG,
			CHAT_JAW,
			CHAT_JABBER,
			CHAT_CHAT,
			CHAT_YACK,
			CHAT_INQUIRE,
			CHAT_INTERRUPT,
			CHAT_SUPPOSE,
			CHAT_JEST,
			CHAT_YELP,
			CHAT_SHRILL,
			CHAT_BOAST,
			CHAT_CONCEDE,
			CHAT_CONCLUDE,
			CHAT_SURMISE,
			CHAT_THEORIZE,
			CHAT_CHANT,
			CHAT_PROPOSE,
			CHAT_RESPOND,
			CHAT_DEBATE,
			CHAT_MUSE,
			CHAT_EMOTE,
			CHAT_WHISPER,
			CHAT_YELL,
			CHAT_SHOUT
		};//all types

/*	  Here's the big list of chat-types for each baloon-types (baloon types in CAPS):

			EXCLAIM
			cheer
			exclaim
			bark
			interject
			blurt
			interrupt
			yelp
			shrill

			THOUGHT
			emote
			muse
			theorize
			conclude
			surmise
			puzzle
			hypothesize
			suppose

			MOAN
			mumble
			grumble
			complain
			groan
			moan

			SCREAM
			cackle
			howl
			scream
			wail

			ICY
			mutter
			retort
			huff

			CHATTER
			babble
			chatter
			drone
			prattle
			ramble
			drivel
			gab
			gossip
			blab
			jaw
			chat
			yack

			WHISPER
			whisper
			mouth
			confide
			confess

			SHOUT
			shout
			yell
			bellow
			vent
			announce

			DROID
			jabber

			STUTTER
			stutter
			grunt
			drawl
			lisp
			slur
			bleat

			SARCASTIC
			jest
			parrot
			flirt
			riddle
			boast

			DOUBLE_RING
			declare
			demand
			decree
			proclaim
			state
			preach
			command
			prophesize
			lecture

			THREATEN
			growl
			threaten
			*/

//---------------------------------------------------------------------------

void chat( obj_id npc, String chatType, String moodType, string_id messageId )
{
	_chat (npc, null, chatType, moodType, null, messageId, null);
}

//---------------------------------------------------------------------------

void chat( obj_id npc, String chatType, string_id messageId )
{
	//since you didn't specify a mood, we'll use the npc's current mood:
	string moodType = getChatMood( npc );
	if ( moodType.equals("none") )
		moodType = null;

	_chat (npc, null, chatType, moodType, null, messageId, null);
}

//---------------------------------------------------------------------------

void think( obj_id npc, String text )
{
	_chat (npc, null, CHAT_EMOTE, null, text, null, null);
}

void thinkTo( obj_id npc, obj_id target, String text )
{

	_chat (npc, target, CHAT_EMOTE, null, chat.ChatFlag_targetOnly, text, null, null);
}

//---------------------------------------------------------------------------

void think( obj_id npc, string_id textId )
{
	_chat (npc, null, CHAT_EMOTE, null, null, textId, null);
}

void thinkTo( obj_id npc, obj_id target, string_id messageId )
{
	_chat (npc, target, CHAT_EMOTE, null, chat.ChatFlag_targetOnly, null, messageId, null);
}


//---------------------------------------------------------------------------

void chat( obj_id npc, string_id messageId )
{
	//since you didn't specify a chatMood, we'll use the npc's current mood:
	string moodType = getChatMood( npc );
	if ( moodType.equals("none") )
		moodType = null;

	//since you didn't specify a chatType, we'll use the npc's current mood:
	string chatType = getChatType( npc );

	_chat (npc, null, chatType, moodType, null, messageId, null);
}

//---------------------------------------------------------------------------

void chat( obj_id npc, obj_id target, string_id messageId, int flags )
{
		//since you didn't specify a chatMood, we'll use the npc's current mood:
	string moodType = getChatMood( npc );
	if ( moodType.equals("none") )
		moodType = null;

	//since you didn't specify a chatType, we'll use the npc's current mood:
	string chatType = getChatType( npc );

	_chat (npc, target, chatType, moodType, flags, null, messageId, null);
}

void chat( obj_id npc, obj_id target, prose_package pp, int flags)
{
	//since you didn't specify a chatMood, we'll use the npc's current mood:
	string moodType = getChatMood( npc );
	if ( moodType.equals("none") )
		moodType = null;

	//since you didn't specify a chatType, we'll use the npc's current type:
	string chatType = getChatType( npc );

	String oob = packOutOfBandProsePackage (null, -1, pp);

	_chat (npc, target, chatType, moodType, flags, null, null, oob);
}

void chat( obj_id npc, obj_id target, string_id messageId)
{

	// check npc for convo objvar
	if(hasObjVar(npc, "convo.appearance"))
	{
		space_utils.tauntPlayer(target, npc, messageId);
	}
	else
	{
			//since you didn't specify a chatMood, we'll use the npc's current mood:
			string moodType = getChatMood( npc );
			if ( moodType.equals("none") )
				moodType = null;

			//since you didn't specify a chatType, we'll use the npc's current mood:
			string chatType = getChatType( npc );

		_chat (npc, target, chatType, moodType, ChatFlag_targetOnly, null, messageId, null);
	}
}

void publicChat( obj_id npc, obj_id target, string_id messageId)
{

	// check npc for convo objvar
	if(hasObjVar(npc, "convo.appearance"))
	{
		space_utils.tauntPlayer(target, npc, messageId);
	}
	else
	{
			//since you didn't specify a chatMood, we'll use the npc's current mood:
			string moodType = getChatMood( npc );
			if ( moodType.equals("none") )
				moodType = null;

			//since you didn't specify a chatType, we'll use the npc's current mood:
			string chatType = getChatType( npc );

		_chat (npc, target, chatType, moodType, 0, null, messageId, null);
	}
}

//---------------------------------------------------------------------------

void chat( obj_id npc, String message )
{
	//since you didn't specify a chatMood, we'll use the npc's current mood:
	string moodType = getChatMood( npc );
	if ( moodType.equals("none") )
		moodType = null;

	//since you didn't specify a chatType, we'll use the npc's current mood:
	string chatType = getChatType( npc );
	_chat (npc, null, chatType, moodType, message, null, null);
}

//---------------------------------------------------------------------------

void chat (obj_id npc, obj_id target, String chatType, String moodType, prose_package pp)
{
	// check npc for convo objvar
	if(hasObjVar(npc, "convo.appearance"))
	{
		space_utils.tauntPlayer(target, npc, pp);
	}
	else
	{
		String oob = packOutOfBandProsePackage (null, -1, pp);
		_chat (npc, target, chatType, moodType, ChatFlag_targetOnly, null, null, oob);
	}
}

void publicChat (obj_id npc, obj_id target, String chatType, String moodType, prose_package pp)
{
	// check npc for convo objvar
	if(hasObjVar(npc, "convo.appearance"))
	{
		space_utils.tauntPlayer(target, npc, pp);
	}
	else
	{
		String oob = packOutOfBandProsePackage (null, -1, pp);
		_chat (npc, target, chatType, moodType, null, null, oob);
	}
}

void chat (obj_id npc, obj_id target, prose_package pp)
{
	// check npc for convo objvar
	if(hasObjVar(npc, "convo.appearance"))
	{
		space_utils.tauntPlayer(target, npc, pp);
	}
	else
	{
		//since you didn't specify a chatMood, we'll use the npc's current mood:
		string moodType = getChatMood( npc );
		if ( moodType.equals("none") )
			moodType = null;

		//since you didn't specify a chatType, we'll use the npc's current mood:
		string chatType = getChatType( npc );

		String oob = packOutOfBandProsePackage (null, -1, pp);
		_chat (npc, target, chatType, moodType, null, null, oob);
	}
}

void chat(obj_id npc, obj_id target, String chatType, string_id blah, int chatFlag)
{
	_chat (npc, target, chatType, null, chatFlag, null, blah, null);
}
void chat (obj_id npc, obj_id target, String text, int flags)
{
		//since you didn't specify a chatMood, we'll use the npc's current mood:
	string moodType = getChatMood( npc );
	if ( moodType.equals("none") )
		moodType = null;

	//since you didn't specify a chatType, we'll use the npc's current mood:
	string chatType = getChatType( npc );

	_chat (npc, target, chatType, moodType, flags, text, null, null);
}

//---------------------------------------------------------------------------

void chat (obj_id npc, obj_id target, String chatType, String moodType, int flags, prose_package pp)
{
	String oob = packOutOfBandProsePackage (null, -1, pp);
	_chat (npc, target, chatType, moodType, flags, null, null, oob);
}

//---------------------------------------------------------------------------


const int ChatFlag_isPrivate           = 0x0001; // target only sees
const int ChatFlag_skipTarget          = 0x0002; // target does not see (internal use only)
const int ChatFlag_skipSource          = 0x0004; // source does not see (internal use only)
const int ChatFlag_targetOnly          = 0x0008; // send only to the target of the chat
const int ChatFlag_targetGroupOnly     = 0x0010; // send to the target of the chat and his group members
const int ChatFlag_targetAndSourceGroup= 0x0100; // send to the target, source, and their group members

//---------------------------------------------------------------------------

/**
* Generic spatial chat functions
* @param npc      the speaker,                    may not be null
* @param target   the target of the spatial chat, may be null
* @param chatType the canonical chat type name,   may be null
* @param moodType the canonical mood type name,   may be null
* @param text     the literal text to speak       may be null
* @param textId   the stringId to speak           may be null
* @param oob      the outOfBand to append         may be null
*
* At least one of text, textId, or oob must be non-null for this function to do anything useful
* If textId is non-null, the server attempts to localize it.  If this fails, then the
* stringId is sent to the client for localization.
*/
void _chat (obj_id npc, obj_id target, String chatType, String moodType, String text, string_id textId, String oob)
{
	_chat (npc, target, chatType, moodType, 0, text, textId, oob);
}

//---------------------------------------------------------------------------

/**
* Generic spatial chat functions
* @param npc      the speaker,                    may not be null
* @param target   the target of the spatial chat, may be null
* @param chatType the canonical chat type name,   may be null
* @param moodType the canonical mood type name,   may be null
* @param text     the literal text to speak       may be null
* @param textId   the stringId to speak           may be null
* @param oob      the outOfBand to append         may be null
*
* At least one of text, textId, or oob must be non-null for this function to do anything useful
* If textId is non-null, the server attempts to localize it.  If this fails, then the
* stringId is sent to the client for localization.
*/
void _chat (obj_id npc, obj_id target, String chatType, String moodType, int flags, String text, string_id textId, String oob)
{
	StringBuffer sbuf = new StringBuffer ();

	if (chatType != null)
		sbuf.append (chatType);
	else
		sbuf.append ('.');
	sbuf.append (' ');

	if (moodType != null)
		sbuf.append (moodType);
	else
		sbuf.append ('.');
	sbuf.append (' ');

	if (textId != null)
	{
		prose_package pp = new prose_package ();
		pp.stringId      = textId;
		pp.actor.id      = npc;
		pp.target.id     = target;

		String local_oob = packOutOfBandProsePackage (oob, -1, pp);

		if (oob != null)
			oob += local_oob;
		else
			oob = local_oob;
	}

	sbuf.append (flags);
	sbuf.append (' ');

	if (text != null)
		sbuf.append (text);

	sbuf.append (' ');

	if (oob != null)
	{
		sbuf.append ('\0');
		sbuf.append (oob);
	}

	queueCommand( npc, ##"spatialChat", target, sbuf.toString (), COMMAND_PRIORITY_DEFAULT);
}

//-----------------------------------------------------------------------

void setChatMood( obj_id npc, string chatMood )
{
	if ( canHaveChatMood( npc ))
		setObjVar( npc, "ai.chatMood", chatMood );
}

string getChatMood( obj_id npc )
{
	if ( !hasObjVar( npc, "ai.chatMood" ))
		return "none";
	else
		return getStringObjVar( npc, "ai.chatMood" );
}

void setChatType( obj_id npc, string chatType )
{
	if ( canHaveChatMood( npc ))
		setObjVar( npc, "ai.chatType", chatType );
}

string getChatType( obj_id npc )
{
	if ( !hasObjVar( npc, "ai.chatType" ))
		return CHAT_SAY;
	else
		return getStringObjVar( npc, "ai.chatType" );
}

//set a random combination of unhappy chat type and unhappy chat mood:
void setBadMood( obj_id npc )
{
	if (!canHaveChatMood( npc ))
		return;

	setObjVar( npc, "ai.chatMood", BADMOODS[ rand(0, BADMOODS.length-1 ) ] );
	setObjVar( npc, "ai.chatType", BADTYPES[ rand(0, BADTYPES.length-1 ) ] );
}

void setGoodMood( obj_id npc )
{
	if (!canHaveChatMood( npc ))
		return;

	setObjVar( npc, "ai.chatMood", GOODMOODS[ rand(0, GOODMOODS.length-1 ) ] );
	setObjVar( npc, "ai.chatType", GOODTYPES[ rand(0, GOODTYPES.length-1 ) ] );
}

void setAngryMood( obj_id npc )
{
	if (!canHaveChatMood( npc ))
		return;

	setObjVar( npc, "ai.chatMood", ANGRYMOODS[ rand(0, ANGRYMOODS.length-1 ) ] );
	setObjVar( npc, "ai.chatType", ANGRYTYPES[ rand(0, ANGRYTYPES.length-1 ) ] );
}

void setNeutralMood( obj_id npc )
{
	if (!canHaveChatMood( npc ))
		return;

	setObjVar( npc, "ai.chatMood", NEUTRALMOODS[ rand(0, NEUTRALMOODS.length-1 ) ] );
	setObjVar( npc, "ai.chatType", NEUTRALTYPES[ rand(0, NEUTRALTYPES.length-1 ) ] );
}

boolean canHaveChatMood( obj_id npc )
{
	if ( ai_lib.aiGetNiche( npc ) != NICHE_NPC )
		return false;

	if ( hasObjVar( npc, "ai.defaultCalmMood" ))
		return false;//dont set chat moods on things with defaultcalm moods, because chatmoods stomp animation moods sucks

	if ( hasObjVar( npc, "ai.noChatMood" ) )
		return false;
	else
		return true;
}

void setTempAnimationMood(obj_id target, string mood)
{
	if ( !isIdValid(target) )
		return;

	string animMood = getAnimationMood(target);
	if ( animMood == null || animMood.equals("") )
		animMood = "default";

	setObjVar(target, "temp.animMood", animMood);
	setAnimationMood(target, mood);
}

void resetTempAnimationMood(obj_id target)
{
	if ( !isIdValid(target) )
		return;

	if ( !hasObjVar(target, "temp.animMood") )
		return;

	string animMood = getStringObjVar(target, "temp.animMood");
	if ( animMood == null || animMood.equals("") || animMood.equals("none") )
		animMood = "default";

	setAnimationMood(target, animMood);
}