diff --git a/action.cpp b/action.cpp index 6437eace30d65..39d3f1b7f0015 100644 --- a/action.cpp +++ b/action.cpp @@ -135,6 +135,8 @@ std::string action_ident(action_id act) return "organize"; case ACTION_USE: return "apply"; + case ACTION_USE_WIELDED: + return "apply_wielded"; case ACTION_WEAR: return "wear"; case ACTION_TAKE_OFF: @@ -172,7 +174,7 @@ std::string action_ident(action_id act) case ACTION_CONSTRUCT: return "construct"; case ACTION_DISASSEMBLE: - return "disassemble"; + return "disassemble"; case ACTION_SLEEP: return "sleep"; case ACTION_TOGGLE_SAFEMODE: @@ -269,6 +271,8 @@ std::string action_name(action_id act) return "Swap Inventory Letters"; case ACTION_USE: return "Apply or Use Item"; + case ACTION_USE_WIELDED: + return "Apply or Use Wielded Item"; case ACTION_WEAR: return "Wear Item"; case ACTION_TAKE_OFF: diff --git a/action.h b/action.h index 639a4a862ce27..6f200e250e267 100644 --- a/action.h +++ b/action.h @@ -29,6 +29,7 @@ ACTION_PEEK, ACTION_INVENTORY, ACTION_ORGANIZE, ACTION_USE, +ACTION_USE_WIELDED, ACTION_WEAR, ACTION_TAKE_OFF, ACTION_EAT, diff --git a/data/NAMES_FEMALE b/data/NAMES_FEMALE deleted file mode 100644 index 0362224a28b92..0000000000000 --- a/data/NAMES_FEMALE +++ /dev/null @@ -1,100 +0,0 @@ -Emma -Isabella -Emily -Madison -Ava -Olivia -Sophie -Abigail -Elizabeth -Chloe -Samantha -Addison -Natalie -Mia -Alexis -Alyssa -Hannah -Ashley -Ella -Sarah -Grace -Brianna -Lily -Hailey -Anna -Victoria -Kayla -Lillian -Lauren -Kaylee -Allison -Savannah -Nevaeh -Gabriella -Sofia -Makayla -Avery -Riley -Julia -Leah -Aubrey -Jasmine -Audrey -Katie -Morgan -Brooklyn -Destiny -Sydney -Alexa -Kylie -Brooke -Kaitlin -Evelyn -Layla -Madeline -Kimberly -Kim -Zoe -Jessica -Jessie -Alexandra -Claire -Madelyn -Maria -Arianna -Jocelyn -Amelia -Angelina -Trinity -Andrea -Maya -Valeria -Sophie -Rachel -Vanessa -Aaliyah -Mariah -Gabrielle -Katelyn -Ariana -Bailey -Camilla -Jennifer -Jen -Melanie -Gianna -Charlotte -Paige -Autumn -Payton -Faith -Sara -Isabelle -Caroline -Genesis -Isabel -Mary -Zoey -Gracie -Megan diff --git a/data/NAMES_LAST b/data/NAMES_LAST deleted file mode 100644 index 4cd43522d92f5..0000000000000 --- a/data/NAMES_LAST +++ /dev/null @@ -1,100 +0,0 @@ -Smith -Johnson -Williams -Jones -Brown -Davis -Miller -Wilson -Moore -Taylor -Anderson -Thomas -Jackson -White -Harris -Martin -Thompson -Garcia -Martinez -Robinson -Clark -Rodriguez -Lewis -Lee -Walker -Hall -Allen -Young -Hernandez -King -Wright -Lopez -Hill -Scott -Green -Adams -Baker -Gonzalez -Nelson -Carter -Mitchell -Perez -Roberts -Turner -Phillips -Campbell -Parker -Evans -Edwards -Collins -Stewart -Sanchez -Morris -Rogers -Reed -Cook -Morgan -Bell -Murphy -Bailey -Rivera -Cooper -Richardson -Cox -Howard -Ward -Torres -Peterson -Gray -Ramirez -James -Watson -Brooks -Kelly -Sanders -Price -Bennett -Wood -Barnes -Ross -Henderson -Coleman -Jenkins -Perry -Powell -Long -Patterson -Hughes -Flores -Washington -Butler -Simmons -Foster -Gonzales -Bryant -Alexander -Russell -Griffin -Diaz -Hayes diff --git a/data/NAMES_MALE b/data/NAMES_MALE deleted file mode 100644 index 2801bd1cf720b..0000000000000 --- a/data/NAMES_MALE +++ /dev/null @@ -1,100 +0,0 @@ -Jacob -Michael -Ethan -Joshua -Daniel -Alexander -Anthony -William -Christopher -Matthew -Jayden -Andrew -Joseph -David -Noah -Aiden -James -Ryan -Logan -John -Nathan -Elijah -Christian -Gabriel -Benjamin -Jonathan -Tyler -Samuel -Nicholas -Gavin -Dylan -Jackson -Brandon -Caleb -Mason -Angel -Isaac -Evan -Jack -Kevin -Jose -Isaiah -Luke -Landon -Justin -Lucas -Zachary -Jordan -Robert -Aaron -Brayden -Thomas -Cameron -Hunter -Austin -Adrian -Connor -Owen -Aidan -Jason -Julian -Wyatt -Charles -Luis -Carter -Juan -Chase -Diego -Jeremiah -Brody -Xavier -Adam -Carlos -Sabastian -Liam -Hayden -Nathaniel -Henry -Jesus -Ian -Tristan -Bryan -Sean -Cole -Alex -Eric -Brian -Jaden -Carson -Blake -Ayden -Cooper -Dominic -Brady -Caden -Josiah -Kyle -Colton -Kaden -Eli diff --git a/data/raw/names.json b/data/raw/names.json new file mode 100644 index 0000000000000..aa5ca4fe9c796 --- /dev/null +++ b/data/raw/names.json @@ -0,0 +1,302 @@ +[ +{ "name" : "Aaliyah", "gender" : "female", "usage" : "given" }, +{ "name" : "Aaron", "gender" : "male", "usage" : "given" }, +{ "name" : "Abigail", "gender" : "female", "usage" : "given" }, +{ "name" : "Adam", "gender" : "male", "usage" : "given" }, +{ "name" : "Adams", "gender" : "unisex", "usage" : "family" }, +{ "name" : "Addison", "gender" : "female", "usage" : "given" }, +{ "name" : "Adrian", "gender" : "male", "usage" : "given" }, +{ "name" : "Aidan", "gender" : "male", "usage" : "given" }, +{ "name" : "Aiden", "gender" : "male", "usage" : "given" }, +{ "name" : "Alex", "gender" : "male", "usage" : "given" }, +{ "name" : "Alexa", "gender" : "female", "usage" : "given" }, +{ "name" : "Alexander", "gender" : "male", "usage" : "given" }, +{ "name" : "Alexander", "gender" : "unisex", "usage" : "family" }, +{ "name" : "Alexandra", "gender" : "female", "usage" : "given" }, +{ "name" : "Alexis", "gender" : "female", "usage" : "given" }, +{ "name" : "Allen", "gender" : "unisex", "usage" : "family" }, +{ "name" : "Allison", "gender" : "female", "usage" : "given" }, +{ "name" : "Alyssa", "gender" : "female", "usage" : "given" }, +{ "name" : "Amelia", "gender" : "female", "usage" : "given" }, +{ "name" : "Anderson", "gender" : "unisex", "usage" : "family" }, +{ "name" : "Andrea", "gender" : "female", "usage" : "given" }, +{ "name" : "Andrew", "gender" : "male", "usage" : "given" }, +{ "name" : "Angel", "gender" : "male", "usage" : "given" }, +{ "name" : "Angelina", "gender" : "female", "usage" : "given" }, +{ "name" : "Anna", "gender" : "female", "usage" : "given" }, +{ "name" : "Anthony", "gender" : "male", "usage" : "given" }, +{ "name" : "Ariana", "gender" : "female", "usage" : "given" }, +{ "name" : "Arianna", "gender" : "female", "usage" : "given" }, +{ "name" : "Ashley", "gender" : "female", "usage" : "given" }, +{ "name" : "Aubrey", "gender" : "female", "usage" : "given" }, +{ "name" : "Audrey", "gender" : "female", "usage" : "given" }, +{ "name" : "Austin", "gender" : "male", "usage" : "given" }, +{ "name" : "Autumn", "gender" : "female", "usage" : "given" }, +{ "name" : "Ava", "gender" : "female", "usage" : "given" }, +{ "name" : "Avery", "gender" : "female", "usage" : "given" }, +{ "name" : "Ayden", "gender" : "male", "usage" : "given" }, +{ "name" : "Bailey", "gender" : "female", "usage" : "given" }, +{ "name" : "Bailey", "gender" : "unisex", "usage" : "family" }, +{ "name" : "Baker", "gender" : "unisex", "usage" : "family" }, +{ "name" : "Barnes", "gender" : "unisex", "usage" : "family" }, +{ "name" : "Bell", "gender" : "unisex", "usage" : "family" }, +{ "name" : "Benjamin", "gender" : "male", "usage" : "given" }, +{ "name" : "Bennett", "gender" : "unisex", "usage" : "family" }, +{ "name" : "Blake", "gender" : "male", "usage" : "given" }, +{ "name" : "Brady", "gender" : "male", "usage" : "given" }, +{ "name" : "Brandon", "gender" : "male", "usage" : "given" }, +{ "name" : "Brayden", "gender" : "male", "usage" : "given" }, +{ "name" : "Brian", "gender" : "male", "usage" : "given" }, +{ "name" : "Brianna", "gender" : "female", "usage" : "given" }, +{ "name" : "Brody", "gender" : "male", "usage" : "given" }, +{ "name" : "Brooke", "gender" : "female", "usage" : "given" }, +{ "name" : "Brooklyn", "gender" : "female", "usage" : "given" }, +{ "name" : "Brooks", "gender" : "unisex", "usage" : "family" }, +{ "name" : "Brown", "gender" : "unisex", "usage" : "family" }, +{ "name" : "Bryan", "gender" : "male", "usage" : "given" }, +{ "name" : "Bryant", "gender" : "unisex", "usage" : "family" }, +{ "name" : "Butler", "gender" : "unisex", "usage" : "family" }, +{ "name" : "Caden", "gender" : "male", "usage" : "given" }, +{ "name" : "Caleb", "gender" : "male", "usage" : "given" }, +{ "name" : "Cameron", "gender" : "male", "usage" : "given" }, +{ "name" : "Camilla", "gender" : "female", "usage" : "given" }, +{ "name" : "Campbell", "gender" : "unisex", "usage" : "family" }, +{ "name" : "Carlos", "gender" : "male", "usage" : "given" }, +{ "name" : "Caroline", "gender" : "female", "usage" : "given" }, +{ "name" : "Carson", "gender" : "male", "usage" : "given" }, +{ "name" : "Carter", "gender" : "male", "usage" : "given" }, +{ "name" : "Carter", "gender" : "unisex", "usage" : "family" }, +{ "name" : "Charles", "gender" : "male", "usage" : "given" }, +{ "name" : "Charlotte", "gender" : "female", "usage" : "given" }, +{ "name" : "Chase", "gender" : "male", "usage" : "given" }, +{ "name" : "Chloe", "gender" : "female", "usage" : "given" }, +{ "name" : "Christian", "gender" : "male", "usage" : "given" }, +{ "name" : "Christopher", "gender" : "male", "usage" : "given" }, +{ "name" : "Claire", "gender" : "female", "usage" : "given" }, +{ "name" : "Clark", "gender" : "unisex", "usage" : "family" }, +{ "name" : "Cole", "gender" : "male", "usage" : "given" }, +{ "name" : "Coleman", "gender" : "unisex", "usage" : "family" }, +{ "name" : "Collins", "gender" : "unisex", "usage" : "family" }, +{ "name" : "Colton", "gender" : "male", "usage" : "given" }, +{ "name" : "Connor", "gender" : "male", "usage" : "given" }, +{ "name" : "Cook", "gender" : "unisex", "usage" : "family" }, +{ "name" : "Cooper", "gender" : "male", "usage" : "given" }, +{ "name" : "Cooper", "gender" : "unisex", "usage" : "family" }, +{ "name" : "Cox", "gender" : "unisex", "usage" : "family" }, +{ "name" : "Daniel", "gender" : "male", "usage" : "given" }, +{ "name" : "David", "gender" : "male", "usage" : "given" }, +{ "name" : "Davis", "gender" : "unisex", "usage" : "family" }, +{ "name" : "Destiny", "gender" : "female", "usage" : "given" }, +{ "name" : "Diaz", "gender" : "unisex", "usage" : "family" }, +{ "name" : "Diego", "gender" : "male", "usage" : "given" }, +{ "name" : "Dominic", "gender" : "male", "usage" : "given" }, +{ "name" : "Dylan", "gender" : "male", "usage" : "given" }, +{ "name" : "Edwards", "gender" : "unisex", "usage" : "family" }, +{ "name" : "Eli", "gender" : "male", "usage" : "given" }, +{ "name" : "Elijah", "gender" : "male", "usage" : "given" }, +{ "name" : "Elizabeth", "gender" : "female", "usage" : "given" }, +{ "name" : "Ella", "gender" : "female", "usage" : "given" }, +{ "name" : "Emily", "gender" : "female", "usage" : "given" }, +{ "name" : "Emma", "gender" : "female", "usage" : "given" }, +{ "name" : "Eric", "gender" : "male", "usage" : "given" }, +{ "name" : "Ethan", "gender" : "male", "usage" : "given" }, +{ "name" : "Evan", "gender" : "male", "usage" : "given" }, +{ "name" : "Evans", "gender" : "unisex", "usage" : "family" }, +{ "name" : "Evelyn", "gender" : "female", "usage" : "given" }, +{ "name" : "Faith", "gender" : "female", "usage" : "given" }, +{ "name" : "Flores", "gender" : "unisex", "usage" : "family" }, +{ "name" : "Foster", "gender" : "unisex", "usage" : "family" }, +{ "name" : "Gabriel", "gender" : "male", "usage" : "given" }, +{ "name" : "Gabriella", "gender" : "female", "usage" : "given" }, +{ "name" : "Gabrielle", "gender" : "female", "usage" : "given" }, +{ "name" : "Garcia", "gender" : "unisex", "usage" : "family" }, +{ "name" : "Gavin", "gender" : "male", "usage" : "given" }, +{ "name" : "Genesis", "gender" : "female", "usage" : "given" }, +{ "name" : "Gianna", "gender" : "female", "usage" : "given" }, +{ "name" : "Gonzales", "gender" : "unisex", "usage" : "family" }, +{ "name" : "Gonzalez", "gender" : "unisex", "usage" : "family" }, +{ "name" : "Grace", "gender" : "female", "usage" : "given" }, +{ "name" : "Gracie", "gender" : "female", "usage" : "given" }, +{ "name" : "Gray", "gender" : "unisex", "usage" : "family" }, +{ "name" : "Green", "gender" : "unisex", "usage" : "family" }, +{ "name" : "Griffin", "gender" : "unisex", "usage" : "family" }, +{ "name" : "Hailey", "gender" : "female", "usage" : "given" }, +{ "name" : "Hall", "gender" : "unisex", "usage" : "family" }, +{ "name" : "Hannah", "gender" : "female", "usage" : "given" }, +{ "name" : "Harris", "gender" : "unisex", "usage" : "family" }, +{ "name" : "Hayden", "gender" : "male", "usage" : "given" }, +{ "name" : "Hayes", "gender" : "unisex", "usage" : "family" }, +{ "name" : "Henderson", "gender" : "unisex", "usage" : "family" }, +{ "name" : "Henry", "gender" : "male", "usage" : "given" }, +{ "name" : "Hernandez", "gender" : "unisex", "usage" : "family" }, +{ "name" : "Hill", "gender" : "unisex", "usage" : "family" }, +{ "name" : "Howard", "gender" : "unisex", "usage" : "family" }, +{ "name" : "Hughes", "gender" : "unisex", "usage" : "family" }, +{ "name" : "Hunter", "gender" : "male", "usage" : "given" }, +{ "name" : "Ian", "gender" : "male", "usage" : "given" }, +{ "name" : "Isaac", "gender" : "male", "usage" : "given" }, +{ "name" : "Isabel", "gender" : "female", "usage" : "given" }, +{ "name" : "Isabella", "gender" : "female", "usage" : "given" }, +{ "name" : "Isabelle", "gender" : "female", "usage" : "given" }, +{ "name" : "Isaiah", "gender" : "male", "usage" : "given" }, +{ "name" : "Jack", "gender" : "male", "usage" : "given" }, +{ "name" : "Jackson", "gender" : "male", "usage" : "given" }, +{ "name" : "Jackson", "gender" : "unisex", "usage" : "family" }, +{ "name" : "Jacob", "gender" : "male", "usage" : "given" }, +{ "name" : "Jaden", "gender" : "male", "usage" : "given" }, +{ "name" : "James", "gender" : "male", "usage" : "given" }, +{ "name" : "James", "gender" : "unisex", "usage" : "family" }, +{ "name" : "Jasmine", "gender" : "female", "usage" : "given" }, +{ "name" : "Jason", "gender" : "male", "usage" : "given" }, +{ "name" : "Jayden", "gender" : "male", "usage" : "given" }, +{ "name" : "Jen", "gender" : "female", "usage" : "given" }, +{ "name" : "Jenkins", "gender" : "unisex", "usage" : "family" }, +{ "name" : "Jennifer", "gender" : "female", "usage" : "given" }, +{ "name" : "Jeremiah", "gender" : "male", "usage" : "given" }, +{ "name" : "Jessica", "gender" : "female", "usage" : "given" }, +{ "name" : "Jessie", "gender" : "female", "usage" : "given" }, +{ "name" : "Jesus", "gender" : "male", "usage" : "given" }, +{ "name" : "Jocelyn", "gender" : "female", "usage" : "given" }, +{ "name" : "John", "gender" : "male", "usage" : "given" }, +{ "name" : "Johnson", "gender" : "unisex", "usage" : "family" }, +{ "name" : "Jonathan", "gender" : "male", "usage" : "given" }, +{ "name" : "Jones", "gender" : "unisex", "usage" : "family" }, +{ "name" : "Jordan", "gender" : "male", "usage" : "given" }, +{ "name" : "Jose", "gender" : "male", "usage" : "given" }, +{ "name" : "Joseph", "gender" : "male", "usage" : "given" }, +{ "name" : "Joshua", "gender" : "male", "usage" : "given" }, +{ "name" : "Josiah", "gender" : "male", "usage" : "given" }, +{ "name" : "Juan", "gender" : "male", "usage" : "given" }, +{ "name" : "Julia", "gender" : "female", "usage" : "given" }, +{ "name" : "Julian", "gender" : "male", "usage" : "given" }, +{ "name" : "Justin", "gender" : "male", "usage" : "given" }, +{ "name" : "Kaden", "gender" : "male", "usage" : "given" }, +{ "name" : "Kaitlin", "gender" : "female", "usage" : "given" }, +{ "name" : "Katelyn", "gender" : "female", "usage" : "given" }, +{ "name" : "Katie", "gender" : "female", "usage" : "given" }, +{ "name" : "Kayla", "gender" : "female", "usage" : "given" }, +{ "name" : "Kaylee", "gender" : "female", "usage" : "given" }, +{ "name" : "Kelly", "gender" : "unisex", "usage" : "family" }, +{ "name" : "Kevin", "gender" : "male", "usage" : "given" }, +{ "name" : "Kim", "gender" : "female", "usage" : "given" }, +{ "name" : "Kimberly", "gender" : "female", "usage" : "given" }, +{ "name" : "King", "gender" : "unisex", "usage" : "family" }, +{ "name" : "Kyle", "gender" : "male", "usage" : "given" }, +{ "name" : "Kylie", "gender" : "female", "usage" : "given" }, +{ "name" : "Landon", "gender" : "male", "usage" : "given" }, +{ "name" : "Lauren", "gender" : "female", "usage" : "given" }, +{ "name" : "Layla", "gender" : "female", "usage" : "given" }, +{ "name" : "Leah", "gender" : "female", "usage" : "given" }, +{ "name" : "Lee", "gender" : "unisex", "usage" : "family" }, +{ "name" : "Lewis", "gender" : "unisex", "usage" : "family" }, +{ "name" : "Liam", "gender" : "male", "usage" : "given" }, +{ "name" : "Lillian", "gender" : "female", "usage" : "given" }, +{ "name" : "Lily", "gender" : "female", "usage" : "given" }, +{ "name" : "Logan", "gender" : "male", "usage" : "given" }, +{ "name" : "Long", "gender" : "unisex", "usage" : "family" }, +{ "name" : "Lopez", "gender" : "unisex", "usage" : "family" }, +{ "name" : "Lucas", "gender" : "male", "usage" : "given" }, +{ "name" : "Luis", "gender" : "male", "usage" : "given" }, +{ "name" : "Luke", "gender" : "male", "usage" : "given" }, +{ "name" : "Madeline", "gender" : "female", "usage" : "given" }, +{ "name" : "Madelyn", "gender" : "female", "usage" : "given" }, +{ "name" : "Madison", "gender" : "female", "usage" : "given" }, +{ "name" : "Makayla", "gender" : "female", "usage" : "given" }, +{ "name" : "Maria", "gender" : "female", "usage" : "given" }, +{ "name" : "Mariah", "gender" : "female", "usage" : "given" }, +{ "name" : "Martin", "gender" : "unisex", "usage" : "family" }, +{ "name" : "Martinez", "gender" : "unisex", "usage" : "family" }, +{ "name" : "Mary", "gender" : "female", "usage" : "given" }, +{ "name" : "Mason", "gender" : "male", "usage" : "given" }, +{ "name" : "Matthew", "gender" : "male", "usage" : "given" }, +{ "name" : "Maya", "gender" : "female", "usage" : "given" }, +{ "name" : "Megan", "gender" : "female", "usage" : "given" }, +{ "name" : "Melanie", "gender" : "female", "usage" : "given" }, +{ "name" : "Mia", "gender" : "female", "usage" : "given" }, +{ "name" : "Michael", "gender" : "male", "usage" : "given" }, +{ "name" : "Miller", "gender" : "unisex", "usage" : "family" }, +{ "name" : "Mitchell", "gender" : "unisex", "usage" : "family" }, +{ "name" : "Moore", "gender" : "unisex", "usage" : "family" }, +{ "name" : "Morgan", "gender" : "female", "usage" : "given" }, +{ "name" : "Morgan", "gender" : "unisex", "usage" : "family" }, +{ "name" : "Morris", "gender" : "unisex", "usage" : "family" }, +{ "name" : "Murphy", "gender" : "unisex", "usage" : "family" }, +{ "name" : "Natalie", "gender" : "female", "usage" : "given" }, +{ "name" : "Nathan", "gender" : "male", "usage" : "given" }, +{ "name" : "Nathaniel", "gender" : "male", "usage" : "given" }, +{ "name" : "Nelson", "gender" : "unisex", "usage" : "family" }, +{ "name" : "Nevaeh", "gender" : "female", "usage" : "given" }, +{ "name" : "Nicholas", "gender" : "male", "usage" : "given" }, +{ "name" : "Noah", "gender" : "male", "usage" : "given" }, +{ "name" : "Olivia", "gender" : "female", "usage" : "given" }, +{ "name" : "Owen", "gender" : "male", "usage" : "given" }, +{ "name" : "Paige", "gender" : "female", "usage" : "given" }, +{ "name" : "Parker", "gender" : "unisex", "usage" : "family" }, +{ "name" : "Patterson", "gender" : "unisex", "usage" : "family" }, +{ "name" : "Payton", "gender" : "female", "usage" : "given" }, +{ "name" : "Perez", "gender" : "unisex", "usage" : "family" }, +{ "name" : "Perry", "gender" : "unisex", "usage" : "family" }, +{ "name" : "Peterson", "gender" : "unisex", "usage" : "family" }, +{ "name" : "Phillips", "gender" : "unisex", "usage" : "family" }, +{ "name" : "Powell", "gender" : "unisex", "usage" : "family" }, +{ "name" : "Price", "gender" : "unisex", "usage" : "family" }, +{ "name" : "Rachel", "gender" : "female", "usage" : "given" }, +{ "name" : "Ramirez", "gender" : "unisex", "usage" : "family" }, +{ "name" : "Reed", "gender" : "unisex", "usage" : "family" }, +{ "name" : "Richardson", "gender" : "unisex", "usage" : "family" }, +{ "name" : "Riley", "gender" : "female", "usage" : "given" }, +{ "name" : "Rivera", "gender" : "unisex", "usage" : "family" }, +{ "name" : "Robert", "gender" : "male", "usage" : "given" }, +{ "name" : "Roberts", "gender" : "unisex", "usage" : "family" }, +{ "name" : "Robinson", "gender" : "unisex", "usage" : "family" }, +{ "name" : "Rodriguez", "gender" : "unisex", "usage" : "family" }, +{ "name" : "Rogers", "gender" : "unisex", "usage" : "family" }, +{ "name" : "Ross", "gender" : "unisex", "usage" : "family" }, +{ "name" : "Russell", "gender" : "unisex", "usage" : "family" }, +{ "name" : "Ryan", "gender" : "male", "usage" : "given" }, +{ "name" : "Sabastian", "gender" : "male", "usage" : "given" }, +{ "name" : "Samantha", "gender" : "female", "usage" : "given" }, +{ "name" : "Samuel", "gender" : "male", "usage" : "given" }, +{ "name" : "Sanchez", "gender" : "unisex", "usage" : "family" }, +{ "name" : "Sanders", "gender" : "unisex", "usage" : "family" }, +{ "name" : "Sara", "gender" : "female", "usage" : "given" }, +{ "name" : "Sarah", "gender" : "female", "usage" : "given" }, +{ "name" : "Savannah", "gender" : "female", "usage" : "given" }, +{ "name" : "Scott", "gender" : "unisex", "usage" : "family" }, +{ "name" : "Sean", "gender" : "male", "usage" : "given" }, +{ "name" : "Simmons", "gender" : "unisex", "usage" : "family" }, +{ "name" : "Smith", "gender" : "unisex", "usage" : "family" }, +{ "name" : "Sofia", "gender" : "female", "usage" : "given" }, +{ "name" : "Sophie", "gender" : "female", "usage" : "given" }, +{ "name" : "Sophie", "gender" : "female", "usage" : "given" }, +{ "name" : "Stewart", "gender" : "unisex", "usage" : "family" }, +{ "name" : "Sydney", "gender" : "female", "usage" : "given" }, +{ "name" : "Taylor", "gender" : "unisex", "usage" : "family" }, +{ "name" : "Thomas", "gender" : "male", "usage" : "given" }, +{ "name" : "Thomas", "gender" : "unisex", "usage" : "family" }, +{ "name" : "Thompson", "gender" : "unisex", "usage" : "family" }, +{ "name" : "Torres", "gender" : "unisex", "usage" : "family" }, +{ "name" : "Trinity", "gender" : "female", "usage" : "given" }, +{ "name" : "Tristan", "gender" : "male", "usage" : "given" }, +{ "name" : "Turner", "gender" : "unisex", "usage" : "family" }, +{ "name" : "Tyler", "gender" : "male", "usage" : "given" }, +{ "name" : "Valeria", "gender" : "female", "usage" : "given" }, +{ "name" : "Vanessa", "gender" : "female", "usage" : "given" }, +{ "name" : "Victoria", "gender" : "female", "usage" : "given" }, +{ "name" : "Walker", "gender" : "unisex", "usage" : "family" }, +{ "name" : "Ward", "gender" : "unisex", "usage" : "family" }, +{ "name" : "Washington", "gender" : "unisex", "usage" : "family" }, +{ "name" : "Watson", "gender" : "unisex", "usage" : "family" }, +{ "name" : "White", "gender" : "unisex", "usage" : "family" }, +{ "name" : "William", "gender" : "male", "usage" : "given" }, +{ "name" : "Williams", "gender" : "unisex", "usage" : "family" }, +{ "name" : "Wilson", "gender" : "unisex", "usage" : "family" }, +{ "name" : "Wood", "gender" : "unisex", "usage" : "family" }, +{ "name" : "Wright", "gender" : "unisex", "usage" : "family" }, +{ "name" : "Wyatt", "gender" : "male", "usage" : "given" }, +{ "name" : "Xavier", "gender" : "male", "usage" : "given" }, +{ "name" : "Young", "gender" : "unisex", "usage" : "family" }, +{ "name" : "Zachary", "gender" : "male", "usage" : "given" }, +{ "name" : "Zoe", "gender" : "female", "usage" : "given" }, +{ "name" : "Zoey", "gender" : "female", "usage" : "given" } +] \ No newline at end of file diff --git a/game.cpp b/game.cpp index a7b06e96c1a06..76053de8427e0 100644 --- a/game.cpp +++ b/game.cpp @@ -1388,6 +1388,10 @@ input_ret game::get_input(int timeout_ms) use_item(); break; + case ACTION_USE_WIELDED: + use_wielded_item(); + break; + case ACTION_WEAR: wear(); break; @@ -4112,6 +4116,11 @@ void game::use_item() u.use(this, ch); } +void game::use_wielded_item() +{ + u.use_wielded(this); +} + bool game::pl_choose_vehicle (int &x, int &y) { refresh_all(); diff --git a/game.h b/game.h index 286cf21091e2b..e064df54fc275 100644 --- a/game.h +++ b/game.h @@ -308,6 +308,7 @@ class game void complete_butcher(int index); // Finish the butchering process void eat(); // Eat food or fuel 'E' (or 'a') void use_item();// Use item; also tries E,R,W 'a' + void use_wielded_item(); void wear(); // Wear armor 'W' (or 'a') void takeoff(); // Remove armor 'T' void reload(); // Reload a wielded gun/tool 'r' diff --git a/keypress.cpp b/keypress.cpp index 8f132fac15ad0..44cf84c099a71 100644 --- a/keypress.cpp +++ b/keypress.cpp @@ -210,6 +210,7 @@ peek L X\n\ inventory i\n\ organize =\n\ apply a\n\ +apply_wielded A\n\ wear W\n\ take_off T\n\ eat E\n\ diff --git a/main.cpp b/main.cpp index 39eeb4af0acba..e0dfd715746c6 100644 --- a/main.cpp +++ b/main.cpp @@ -7,7 +7,7 @@ #if (defined _WIN32 || defined WINDOWS) #include "catacurse.h" #elif (defined __CYGWIN__) - #include "ncurses/curses.h" + #include "ncurses/curses.h" #else #include #endif @@ -20,14 +20,11 @@ #include "debug.h" //#include - int main(int argc, char *argv[]) { #ifdef ENABLE_LOGGING - setupDebug(); + setupDebug(); #endif - srand(time(NULL)); - // ncurses stuff initscr(); // Initialize ncurses noecho(); // Don't echo keypresses @@ -36,8 +33,8 @@ int main(int argc, char *argv[]) init_colors(); // See color.cpp curs_set(0); // Invisible cursor - rand(); // For some reason a call to rand() seems to be necessary to avoid - // repetion. + std::srand(time(NULL)); + bool quit_game = false; bool delete_world = false; game *g = new game; @@ -46,12 +43,12 @@ int main(int argc, char *argv[]) load_options(); do { g->setup(); - while (!g->do_turn()); + while (!g->do_turn()) ; if (g->uquit == QUIT_DELETE_WORLD) delete_world = true; if (g->game_quit()) quit_game = true; - } while (!quit_game); + } while (!quit_game); MAPBUFFER.save(); if (delete_world && (remove("save/") != 0)) @@ -60,9 +57,9 @@ int main(int argc, char *argv[]) system("rmdir /s /q save"); #else system("rm -rf save/*"); - #endif + #endif } - + erase(); // Clear screen endwin(); // End ncurses #if (defined _WIN32 || defined WINDOWS) @@ -73,4 +70,3 @@ int main(int argc, char *argv[]) #endif return 0; } - diff --git a/mission_start.cpp b/mission_start.cpp index 8ad4a9fe5880d..3ba0dbf0105a1 100644 --- a/mission_start.cpp +++ b/mission_start.cpp @@ -1,5 +1,6 @@ #include "mission.h" #include "game.h" +#include "name.h" #include /* These functions are responsible for making changes to the game at the moment @@ -66,8 +67,7 @@ void mission_start::place_zombie_mom(game *g, mission *miss) tinymap zomhouse(&(g->itypes), &(g->mapitems), &(g->traps)); zomhouse.load(g, house.x * 2, house.y * 2, false); - zomhouse.add_spawn(mon_zombie, 1, SEEX, SEEY, false, -1, miss->uid, - random_first_name(false)); + zomhouse.add_spawn(mon_zombie, 1, SEEX, SEEY, false, -1, miss->uid, Name::get(nameIsFemaleName | nameIsGivenName)); zomhouse.save(&(g->cur_om), int(g->turn), house.x * 2, house.y * 2); } diff --git a/name.cpp b/name.cpp new file mode 100644 index 0000000000000..c61a8917be851 --- /dev/null +++ b/name.cpp @@ -0,0 +1,98 @@ +#include +#include +#include +#include + +#include "name.h" +#include "picojson.h" + +NameGenerator::NameGenerator() { + std::ifstream rawFile; + picojson::value rawData; + + rawFile.open("data/raw/names.json"); + + rawFile >> rawData; + + rawFile.close(); + + const picojson::array& rawNames = rawData.get(); + for (picojson::array::const_iterator i = rawNames.begin(); i != rawNames.end(); ++i) { + std::map aNameData = i->get >(); + + std::string name, gender, usage; + uint32_t flags = 0; + + name = aNameData["name"].get(); + + gender = aNameData["gender"].get(); + + if (gender == "male") { + flags |= nameIsMaleName; + } else if (gender == "female") { + flags |= nameIsFemaleName; + } else if (gender == "unisex") { + flags |= nameIsUnisexName; + } + + usage = aNameData["usage"].get(); + + if (usage == "given") { + flags |= nameIsGivenName; + } else if (usage == "family") { + flags |= nameIsFamilyName; + } else if (usage == "universal") { + flags |= nameIsGivenName | nameIsFamilyName; + } + + Name aName(name, flags); + + names.push_back(aName); + } +} + +std::vector NameGenerator::filteredNames(uint32_t searchFlags) { + std::vector retval; + + for (std::vector::const_iterator aName = names.begin(); aName != names.end(); ++aName) { + if ((aName->flags() & searchFlags) == searchFlags) + retval.push_back(aName->value()); + } + + return retval; +} + +std::string NameGenerator::getName(uint32_t searchFlags) { + std::vector theseNames = filteredNames(searchFlags); + + return theseNames[std::rand() % theseNames.size()]; +} + +std::string NameGenerator::generateName(bool male) { + uint32_t baseSearchFlags = male ? nameIsMaleName : nameIsFemaleName; + + return getName(baseSearchFlags | nameIsGivenName) + " " + getName(baseSearchFlags | nameIsFamilyName); +} + + +NameGenerator& Name::generator() { + return NameGenerator::generator(); +} + +std::string Name::generate(bool male) { + return NameGenerator::generator().generateName(male); +} + +std::string Name::get(uint32_t searchFlags) { + return NameGenerator::generator().getName(searchFlags); +} + +Name::Name() { + _value = "Tom"; + _flags = 15; +} + +Name::Name(std::string name, uint32_t flags) { + _value = name; + _flags = flags; +} diff --git a/name.h b/name.h new file mode 100644 index 0000000000000..1ca0c86d15fe3 --- /dev/null +++ b/name.h @@ -0,0 +1,62 @@ +#ifndef _NAME_H_ +#define _NAME_H_ + +#include +#include + +typedef enum { + nameIsMaleName = 1, + nameIsFemaleName = 2, + nameIsUnisexName = 3, + nameIsGivenName = 4, + nameIsFamilyName = 8 +} nameFlags; + +class NameGenerator; + +class Name { + public: + Name(); + Name(std::string name, uint32_t flags); + + static NameGenerator& generator(); + static std::string generate(bool male); + + static std::string get(uint32_t searchFlags); + + std::string value() const { return _value; } + uint32_t flags() const { return _flags; } + + bool isFirstName(); + bool isLastName(); + + bool isMaleName(); + bool isFemaleName(); + private: + std::string _value; + uint32_t _flags; +}; + +class NameGenerator { + public: + static NameGenerator& generator() { + static NameGenerator generator; + + return generator; + } + + std::string generateName(bool male); + + std::vector filteredNames(uint32_t searchFlags); + std::string getName(uint32_t searchFlags); + + private: + NameGenerator(); + + NameGenerator(NameGenerator const&); + void operator=(NameGenerator const&); + + std::vector names; +}; + +#endif diff --git a/newcharacter.cpp b/newcharacter.cpp index e8264e25df43c..a877ba076fc37 100644 --- a/newcharacter.cpp +++ b/newcharacter.cpp @@ -3,6 +3,7 @@ #include "rng.h" #include "keypress.h" #include "game.h" +#include "options.h" #include #include #include @@ -143,7 +144,7 @@ bool player::create(game *g, character_type type, std::string tempname) } tab = 3; } else - points = 6; + points = OPTIONS[OPT_INITIAL_POINTS]; do { werase(w); diff --git a/options.cpp b/options.cpp index af3d31808c35a..0dff4d7935fa4 100644 --- a/options.cpp +++ b/options.cpp @@ -79,13 +79,15 @@ option_key lookup_option_key(std::string id) if (id == "gradual_night_light") return OPT_GRADUAL_NIGHT_LIGHT; if (id == "query_disassemble") - return OPT_QUERY_DISASSEMBLE; + return OPT_QUERY_DISASSEMBLE; if (id == "drop_empty") - return OPT_DROP_EMPTY; + return OPT_DROP_EMPTY; if (id == "skill_rust") return OPT_SKILL_RUST; if (id == "delete_world") - return OPT_DELETE_WORLD; + return OPT_DELETE_WORLD; + if (id == "initial_points") + return OPT_INITIAL_POINTS; return OPT_NULL; } @@ -105,7 +107,8 @@ std::string option_string(option_key key) case OPT_QUERY_DISASSEMBLE: return "query_disassemble"; case OPT_DROP_EMPTY: return "drop_empty"; case OPT_SKILL_RUST: return "skill_rust"; - case OPT_DELETE_WORLD: return "delete_world"; + case OPT_DELETE_WORLD: return "delete_world"; + case OPT_INITIAL_POINTS: return "inital_points"; default: return "unknown_option"; } return "unknown_option"; @@ -125,9 +128,10 @@ std::string option_desc(option_key key) case OPT_AUTOSAVE: return "If true, game will periodically\nsave the map"; case OPT_GRADUAL_NIGHT_LIGHT: return "If true will add nice gradual-lighting\n(should only make a difference @night)"; case OPT_QUERY_DISASSEMBLE: return "If true, will query before disassembling\nitems"; - case OPT_DROP_EMPTY: return "Set to drop empty containers after use\n0 - don't drop any\n1 - all except watertight containers\n2 - all containers"; + case OPT_DROP_EMPTY: return "Set to drop empty containers after use\n0 - don't drop any\n1 - all except watertight containers\n2 - all containers"; case OPT_SKILL_RUST: return "Set the level of skill rust\n0 - vanilla Cataclysm\n1 - capped at skill levels\n2 - none at all"; case OPT_DELETE_WORLD: return "Delete saves upon player death\n0 - no\n1 - yes\n2 - query"; + case OPT_INITIAL_POINTS: return "Initial points available on character generation.\nDefault is 6"; default: return " "; } return "Big ol Bug"; @@ -147,9 +151,10 @@ std::string option_name(option_key key) case OPT_AUTOSAVE: return "Periodically Autosave"; case OPT_GRADUAL_NIGHT_LIGHT: return "Gradual night light"; case OPT_QUERY_DISASSEMBLE: return "Query on disassembly"; - case OPT_DROP_EMPTY: return "Drop empty containers"; + case OPT_DROP_EMPTY: return "Drop empty containers"; case OPT_SKILL_RUST: return "Skill Rust"; - case OPT_DELETE_WORLD: return "Delete World"; + case OPT_DELETE_WORLD: return "Delete World"; + case OPT_INITIAL_POINTS: return "Intial points"; default: return "Unknown Option (BUG)"; } return "Big ol Bug"; @@ -161,6 +166,7 @@ bool option_is_bool(option_key id) case OPT_SKILL_RUST: case OPT_DROP_EMPTY: case OPT_DELETE_WORLD: + case OPT_INITIAL_POINTS: return false; break; default: @@ -172,11 +178,14 @@ bool option_is_bool(option_key id) char option_max_options(option_key id) { char ret; - if (option_is_bool(id)) + if (option_is_bool(id)) ret = 2; else switch (id) { + case OPT_INITIAL_POINTS: + ret = 25; + break; case OPT_DELETE_WORLD: case OPT_DROP_EMPTY: case OPT_SKILL_RUST: @@ -228,6 +237,8 @@ drop_empty 0\n\ skill_rust 0\n\ # Delete world after player death: 0 - no, 1 - yes, 2 - query\n\ delete_world 0\n\ +# Initial points available in character generation\n\ +initial_points 6\n\ "; fout.close(); } diff --git a/options.h b/options.h index 1588aa7b50715..233912a1d0f9b 100644 --- a/options.h +++ b/options.h @@ -19,6 +19,7 @@ OPT_QUERY_DISASSEMBLE, // Query before disassembling items OPT_DROP_EMPTY, // auto drop empty containers after use OPT_SKILL_RUST, // level of skill rust OPT_DELETE_WORLD, +OPT_INITIAL_POINTS, NUM_OPTION_KEYS }; diff --git a/picojson.h b/picojson.h new file mode 100644 index 0000000000000..356d2b88138b2 --- /dev/null +++ b/picojson.h @@ -0,0 +1,998 @@ +/* + * Copyright 2009-2010 Cybozu Labs, Inc. + * Copyright 2011 Kazuho Oku + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY CYBOZU LABS, INC. ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO + * EVENT SHALL CYBOZU LABS, INC. OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, + * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + * The views and conclusions contained in the software and documentation are + * those of the authors and should not be interpreted as representing official + * policies, either expressed or implied, of Cybozu Labs, Inc. + * + */ +#ifndef picojson_h +#define picojson_h + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#ifdef _MSC_VER + #define SNPRINTF _snprintf_s + #pragma warning(push) + #pragma warning(disable : 4244) // conversion from int to char +#else + #define SNPRINTF snprintf +#endif + +namespace picojson { + + enum { + null_type, + boolean_type, + number_type, + string_type, + array_type, + object_type + }; + + struct null {}; + + class value { + public: + typedef std::vector array; + typedef std::map object; + protected: + int type_; + union { + bool boolean_; + double number_; + std::string* string_; + array* array_; + object* object_; + }; + public: + value(); + value(int type, bool); + explicit value(bool b); + explicit value(double n); + explicit value(const std::string& s); + explicit value(const array& a); + explicit value(const object& o); + explicit value(const char* s); + value(const char* s, size_t len); + ~value(); + value(const value& x); + value& operator=(const value& x); + template bool is() const; + template const T& get() const; + template T& get(); + bool evaluate_as_boolean() const; + const value& get(size_t idx) const; + const value& get(const std::string& key) const; + bool contains(size_t idx) const; + bool contains(const std::string& key) const; + std::string to_str() const; + template void serialize(Iter os) const; + std::string serialize() const; + private: + template value(const T*); // intentionally defined to block implicit conversion of pointer to bool + }; + + typedef value::array array; + typedef value::object object; + + inline value::value() : type_(null_type) {} + + inline value::value(int type, bool) : type_(type) { + switch (type) { +#define INIT(p, v) case p##type: p = v; break + INIT(boolean_, false); + INIT(number_, 0.0); + INIT(string_, new std::string()); + INIT(array_, new array()); + INIT(object_, new object()); +#undef INIT + default: break; + } + } + + inline value::value(bool b) : type_(boolean_type) { + boolean_ = b; + } + + inline value::value(double n) : type_(number_type) { + number_ = n; + } + + inline value::value(const std::string& s) : type_(string_type) { + string_ = new std::string(s); + } + + inline value::value(const array& a) : type_(array_type) { + array_ = new array(a); + } + + inline value::value(const object& o) : type_(object_type) { + object_ = new object(o); + } + + inline value::value(const char* s) : type_(string_type) { + string_ = new std::string(s); + } + + inline value::value(const char* s, size_t len) : type_(string_type) { + string_ = new std::string(s, len); + } + + inline value::~value() { + switch (type_) { +#define DEINIT(p) case p##type: delete p; break + DEINIT(string_); + DEINIT(array_); + DEINIT(object_); +#undef DEINIT + default: break; + } + } + + inline value::value(const value& x) : type_(x.type_) { + switch (type_) { +#define INIT(p, v) case p##type: p = v; break + INIT(boolean_, x.boolean_); + INIT(number_, x.number_); + INIT(string_, new std::string(*x.string_)); + INIT(array_, new array(*x.array_)); + INIT(object_, new object(*x.object_)); +#undef INIT + default: break; + } + } + + inline value& value::operator=(const value& x) { + if (this != &x) { + this->~value(); + new (this) value(x); + } + return *this; + } + +#define IS(ctype, jtype) \ + template <> inline bool value::is() const { \ + return type_ == jtype##_type; \ + } + IS(null, null) + IS(bool, boolean) + IS(int, number) + IS(double, number) + IS(std::string, string) + IS(array, array) + IS(object, object) +#undef IS + +#define GET(ctype, var) \ + template <> inline const ctype& value::get() const { \ + assert("type mismatch! call vis() before get()" \ + && is()); \ + return var; \ + } \ + template <> inline ctype& value::get() { \ + assert("type mismatch! call is() before get()" \ + && is()); \ + return var; \ + } + GET(bool, boolean_) + GET(double, number_) + GET(std::string, *string_) + GET(array, *array_) + GET(object, *object_) +#undef GET + + inline bool value::evaluate_as_boolean() const { + switch (type_) { + case null_type: + return false; + case boolean_type: + return boolean_; + case number_type: + return number_ != 0; + case string_type: + return ! string_->empty(); + default: + return true; + } + } + + inline const value& value::get(size_t idx) const { + static value s_null; + assert(is()); + return idx < array_->size() ? (*array_)[idx] : s_null; + } + + inline const value& value::get(const std::string& key) const { + static value s_null; + assert(is()); + object::const_iterator i = object_->find(key); + return i != object_->end() ? i->second : s_null; + } + + inline bool value::contains(size_t idx) const { + assert(is()); + return idx < array_->size(); + } + + inline bool value::contains(const std::string& key) const { + assert(is()); + object::const_iterator i = object_->find(key); + return i != object_->end(); + } + + inline std::string value::to_str() const { + switch (type_) { + case null_type: return "null"; + case boolean_type: return boolean_ ? "true" : "false"; + case number_type: { + char buf[256]; + double tmp; + SNPRINTF(buf, sizeof(buf), fabs(number_) < (1ULL << 53) && modf(number_, &tmp) == 0 ? "%.f" : "%.17g", number_); + return buf; + } + case string_type: return *string_; + case array_type: return "array"; + case object_type: return "object"; + default: assert(0); +#ifdef _MSC_VER + __assume(0); +#endif + } + } + + template void copy(const std::string& s, Iter oi) { + std::copy(s.begin(), s.end(), oi); + } + + template void serialize_str(const std::string& s, Iter oi) { + *oi++ = '"'; + for (std::string::const_iterator i = s.begin(); i != s.end(); ++i) { + switch (*i) { +#define MAP(val, sym) case val: copy(sym, oi); break + MAP('"', "\\\""); + MAP('\\', "\\\\"); + MAP('/', "\\/"); + MAP('\b', "\\b"); + MAP('\f', "\\f"); + MAP('\n', "\\n"); + MAP('\r', "\\r"); + MAP('\t', "\\t"); +#undef MAP + default: + if ((unsigned char)*i < 0x20 || *i == 0x7f) { + char buf[7]; + SNPRINTF(buf, sizeof(buf), "\\u%04x", *i & 0xff); + copy(buf, buf + 6, oi); + } else { + *oi++ = *i; + } + break; + } + } + *oi++ = '"'; + } + + template void value::serialize(Iter oi) const { + switch (type_) { + case string_type: + serialize_str(*string_, oi); + break; + case array_type: { + *oi++ = '['; + for (array::const_iterator i = array_->begin(); i != array_->end(); ++i) { + if (i != array_->begin()) { + *oi++ = ','; + } + i->serialize(oi); + } + *oi++ = ']'; + break; + } + case object_type: { + *oi++ = '{'; + for (object::const_iterator i = object_->begin(); + i != object_->end(); + ++i) { + if (i != object_->begin()) { + *oi++ = ','; + } + serialize_str(i->first, oi); + *oi++ = ':'; + i->second.serialize(oi); + } + *oi++ = '}'; + break; + } + default: + copy(to_str(), oi); + break; + } + } + + inline std::string value::serialize() const { + std::string s; + serialize(std::back_inserter(s)); + return s; + } + + template class input { + protected: + Iter cur_, end_; + int last_ch_; + bool ungot_; + int line_; + public: + input(const Iter& first, const Iter& last) : cur_(first), end_(last), last_ch_(-1), ungot_(false), line_(1) {} + int getc() { + if (ungot_) { + ungot_ = false; + return last_ch_; + } + if (cur_ == end_) { + last_ch_ = -1; + return -1; + } + if (last_ch_ == '\n') { + line_++; + } + last_ch_ = *cur_++ & 0xff; + return last_ch_; + } + void ungetc() { + if (last_ch_ != -1) { + assert(! ungot_); + ungot_ = true; + } + } + Iter cur() const { return cur_; } + int line() const { return line_; } + void skip_ws() { + while (1) { + int ch = getc(); + if (! (ch == ' ' || ch == '\t' || ch == '\n' || ch == '\r')) { + ungetc(); + break; + } + } + } + bool expect(int expect) { + skip_ws(); + if (getc() != expect) { + ungetc(); + return false; + } + return true; + } + bool match(const std::string& pattern) { + for (std::string::const_iterator pi(pattern.begin()); + pi != pattern.end(); + ++pi) { + if (getc() != *pi) { + ungetc(); + return false; + } + } + return true; + } + }; + + template inline int _parse_quadhex(input &in) { + int uni_ch = 0, hex; + for (int i = 0; i < 4; i++) { + if ((hex = in.getc()) == -1) { + return -1; + } + if ('0' <= hex && hex <= '9') { + hex -= '0'; + } else if ('A' <= hex && hex <= 'F') { + hex -= 'A' - 0xa; + } else if ('a' <= hex && hex <= 'f') { + hex -= 'a' - 0xa; + } else { + in.ungetc(); + return -1; + } + uni_ch = uni_ch * 16 + hex; + } + return uni_ch; + } + + template inline bool _parse_codepoint(String& out, input& in) { + int uni_ch; + if ((uni_ch = _parse_quadhex(in)) == -1) { + return false; + } + if (0xd800 <= uni_ch && uni_ch <= 0xdfff) { + if (0xdc00 <= uni_ch) { + // a second 16-bit of a surrogate pair appeared + return false; + } + // first 16-bit of surrogate pair, get the next one + if (in.getc() != '\\' || in.getc() != 'u') { + in.ungetc(); + return false; + } + int second = _parse_quadhex(in); + if (! (0xdc00 <= second && second <= 0xdfff)) { + return false; + } + uni_ch = ((uni_ch - 0xd800) << 10) | ((second - 0xdc00) & 0x3ff); + uni_ch += 0x10000; + } + if (uni_ch < 0x80) { + out.push_back(uni_ch); + } else { + if (uni_ch < 0x800) { + out.push_back(0xc0 | (uni_ch >> 6)); + } else { + if (uni_ch < 0x10000) { + out.push_back(0xe0 | (uni_ch >> 12)); + } else { + out.push_back(0xf0 | (uni_ch >> 18)); + out.push_back(0x80 | ((uni_ch >> 12) & 0x3f)); + } + out.push_back(0x80 | ((uni_ch >> 6) & 0x3f)); + } + out.push_back(0x80 | (uni_ch & 0x3f)); + } + return true; + } + + template inline bool _parse_string(String& out, input& in) { + while (1) { + int ch = in.getc(); + if (ch < ' ') { + in.ungetc(); + return false; + } else if (ch == '"') { + return true; + } else if (ch == '\\') { + if ((ch = in.getc()) == -1) { + return false; + } + switch (ch) { +#define MAP(sym, val) case sym: out.push_back(val); break + MAP('"', '\"'); + MAP('\\', '\\'); + MAP('/', '/'); + MAP('b', '\b'); + MAP('f', '\f'); + MAP('n', '\n'); + MAP('r', '\r'); + MAP('t', '\t'); +#undef MAP + case 'u': + if (! _parse_codepoint(out, in)) { + return false; + } + break; + default: + return false; + } + } else { + out.push_back(ch); + } + } + return false; + } + + template inline bool _parse_array(Context& ctx, input& in) { + if (! ctx.parse_array_start()) { + return false; + } + if (in.expect(']')) { + return true; + } + size_t idx = 0; + do { + if (! ctx.parse_array_item(in, idx)) { + return false; + } + idx++; + } while (in.expect(',')); + return in.expect(']'); + } + + template inline bool _parse_object(Context& ctx, input& in) { + if (! ctx.parse_object_start()) { + return false; + } + if (in.expect('}')) { + return true; + } + do { + std::string key; + if (! in.expect('"') + || ! _parse_string(key, in) + || ! in.expect(':')) { + return false; + } + if (! ctx.parse_object_item(in, key)) { + return false; + } + } while (in.expect(',')); + return in.expect('}'); + } + + template inline bool _parse_number(double& out, input& in) { + std::string num_str; + while (1) { + int ch = in.getc(); + if (('0' <= ch && ch <= '9') || ch == '+' || ch == '-' || ch == '.' + || ch == 'e' || ch == 'E') { + num_str.push_back(ch); + } else { + in.ungetc(); + break; + } + } + char* endp; + out = strtod(num_str.c_str(), &endp); + return endp == num_str.c_str() + num_str.size(); + } + + template inline bool _parse(Context& ctx, input& in) { + in.skip_ws(); + int ch = in.getc(); + switch (ch) { +#define IS(ch, text, op) case ch: \ + if (in.match(text) && op) { \ + return true; \ + } else { \ + return false; \ + } + IS('n', "ull", ctx.set_null()); + IS('f', "alse", ctx.set_bool(false)); + IS('t', "rue", ctx.set_bool(true)); +#undef IS + case '"': + return ctx.parse_string(in); + case '[': + return _parse_array(ctx, in); + case '{': + return _parse_object(ctx, in); + default: + if (('0' <= ch && ch <= '9') || ch == '-') { + in.ungetc(); + double f; + if (_parse_number(f, in)) { + ctx.set_number(f); + return true; + } else { + return false; + } + } + break; + } + in.ungetc(); + return false; + } + + class deny_parse_context { + public: + bool set_null() { return false; } + bool set_bool(bool) { return false; } + bool set_number(double) { return false; } + template bool parse_string(input&) { return false; } + bool parse_array_start() { return false; } + template bool parse_array_item(input&, size_t) { + return false; + } + bool parse_object_start() { return false; } + template bool parse_object_item(input&, const std::string&) { + return false; + } + }; + + class default_parse_context { + protected: + value* out_; + public: + default_parse_context(value* out) : out_(out) {} + bool set_null() { + *out_ = value(); + return true; + } + bool set_bool(bool b) { + *out_ = value(b); + return true; + } + bool set_number(double f) { + *out_ = value(f); + return true; + } + template bool parse_string(input& in) { + *out_ = value(string_type, false); + return _parse_string(out_->get(), in); + } + bool parse_array_start() { + *out_ = value(array_type, false); + return true; + } + template bool parse_array_item(input& in, size_t) { + array& a = out_->get(); + a.push_back(value()); + default_parse_context ctx(&a.back()); + return _parse(ctx, in); + } + bool parse_object_start() { + *out_ = value(object_type, false); + return true; + } + template bool parse_object_item(input& in, const std::string& key) { + object& o = out_->get(); + default_parse_context ctx(&o[key]); + return _parse(ctx, in); + } + private: + default_parse_context(const default_parse_context&); + default_parse_context& operator=(const default_parse_context&); + }; + + class null_parse_context { + public: + struct dummy_str { + void push_back(int) {} + }; + public: + null_parse_context() {} + bool set_null() { return true; } + bool set_bool(bool) { return true; } + bool set_number(double) { return true; } + template bool parse_string(input& in) { + dummy_str s; + return _parse_string(s, in); + } + bool parse_array_start() { return true; } + template bool parse_array_item(input& in, size_t) { + return _parse(*this, in); + } + bool parse_object_start() { return true; } + template bool parse_object_item(input& in, const std::string&) { + return _parse(*this, in); + } + private: + null_parse_context(const null_parse_context&); + null_parse_context& operator=(const null_parse_context&); + }; + + // obsolete, use the version below + template inline std::string parse(value& out, Iter& pos, const Iter& last) { + std::string err; + pos = parse(out, pos, last, &err); + return err; + } + + template inline Iter _parse(Context& ctx, const Iter& first, const Iter& last, std::string* err) { + input in(first, last); + if (! _parse(ctx, in) && err != NULL) { + char buf[64]; + SNPRINTF(buf, sizeof(buf), "syntax error at line %d near: ", in.line()); + *err = buf; + while (1) { + int ch = in.getc(); + if (ch == -1 || ch == '\n') { + break; + } else if (ch >= ' ') { + err->push_back(ch); + } + } + } + return in.cur(); + } + + template inline Iter parse(value& out, const Iter& first, const Iter& last, std::string* err) { + default_parse_context ctx(&out); + return _parse(ctx, first, last, err); + } + + inline std::string parse(value& out, std::istream& is) { + std::string err; + parse(out, std::istreambuf_iterator(is.rdbuf()), + std::istreambuf_iterator(), &err); + return err; + } + + template struct last_error_t { + static std::string s; + }; + template std::string last_error_t::s; + + inline void set_last_error(const std::string& s) { + last_error_t::s = s; + } + + inline const std::string& get_last_error() { + return last_error_t::s; + } + + inline bool operator==(const value& x, const value& y) { + if (x.is()) + return y.is(); +#define PICOJSON_CMP(type) \ + if (x.is()) \ + return y.is() && x.get() == y.get() + PICOJSON_CMP(bool); + PICOJSON_CMP(double); + PICOJSON_CMP(std::string); + PICOJSON_CMP(array); + PICOJSON_CMP(object); +#undef PICOJSON_CMP + assert(0); +#ifdef _MSC_VER + __assume(0); +#endif + return false; + } + + inline bool operator!=(const value& x, const value& y) { + return ! (x == y); + } +} + +inline std::istream& operator>>(std::istream& is, picojson::value& x) +{ + picojson::set_last_error(std::string()); + std::string err = picojson::parse(x, is); + if (! err.empty()) { + picojson::set_last_error(err); + is.setstate(std::ios::failbit); + } + return is; +} + +inline std::ostream& operator<<(std::ostream& os, const picojson::value& x) +{ + x.serialize(std::ostream_iterator(os)); + return os; +} +#ifdef _MSC_VER + #pragma warning(pop) +#endif + +#endif +#ifdef TEST_PICOJSON +#ifdef _MSC_VER + #pragma warning(disable : 4127) // conditional expression is constant +#endif + +using namespace std; + +static void plan(int num) +{ + printf("1..%d\n", num); +} + +static bool success = true; + +static void ok(bool b, const char* name = "") +{ + static int n = 1; + if (! b) + success = false; + printf("%s %d - %s\n", b ? "ok" : "ng", n++, name); +} + +template void is(const T& x, const T& y, const char* name = "") +{ + if (x == y) { + ok(true, name); + } else { + ok(false, name); + } +} + +#include +#include +#include + +int main(void) +{ + plan(75); + + // constructors +#define TEST(expr, expected) \ + is(picojson::value expr .serialize(), string(expected), "picojson::value" #expr) + + TEST( (true), "true"); + TEST( (false), "false"); + TEST( (42.0), "42"); + TEST( (string("hello")), "\"hello\""); + TEST( ("hello"), "\"hello\""); + TEST( ("hello", 4), "\"hell\""); + + { + double a = 1; + for (int i = 0; i < 1024; i++) { + picojson::value vi(a); + std::stringstream ss; + ss << vi; + picojson::value vo; + ss >> vo; + double b = vo.get(); + if ((i < 53 && a != b) || fabs(a - b) / b > 1e-8) { + printf("ng i=%d a=%.18e b=%.18e\n", i, a, b); + } + a *= 2; + } + } + +#undef TEST + +#define TEST(in, type, cmp, serialize_test) { \ + picojson::value v; \ + const char* s = in; \ + string err = picojson::parse(v, s, s + strlen(s)); \ + ok(err.empty(), in " no error"); \ + ok(v.is(), in " check type"); \ + is(v.get(), cmp, in " correct output"); \ + is(*s, '\0', in " read to eof"); \ + if (serialize_test) { \ + is(v.serialize(), string(in), in " serialize"); \ + } \ + } + TEST("false", bool, false, true); + TEST("true", bool, true, true); + TEST("90.5", double, 90.5, false); + TEST("1.7976931348623157e+308", double, DBL_MAX, false); + TEST("\"hello\"", string, string("hello"), true); + TEST("\"\\\"\\\\\\/\\b\\f\\n\\r\\t\"", string, string("\"\\/\b\f\n\r\t"), + true); + TEST("\"\\u0061\\u30af\\u30ea\\u30b9\"", string, + string("a\xe3\x82\xaf\xe3\x83\xaa\xe3\x82\xb9"), false); + TEST("\"\\ud840\\udc0b\"", string, string("\xf0\xa0\x80\x8b"), false); +#undef TEST + +#define TEST(type, expr) { \ + picojson::value v; \ + const char *s = expr; \ + string err = picojson::parse(v, s, s + strlen(s)); \ + ok(err.empty(), "empty " #type " no error"); \ + ok(v.is(), "empty " #type " check type"); \ + ok(v.get().empty(), "check " #type " array size"); \ + } + TEST(array, "[]"); + TEST(object, "{}"); +#undef TEST + + { + picojson::value v; + const char *s = "[1,true,\"hello\"]"; + string err = picojson::parse(v, s, s + strlen(s)); + ok(err.empty(), "array no error"); + ok(v.is(), "array check type"); + is(v.get().size(), size_t(3), "check array size"); + ok(v.contains(0), "check contains array[0]"); + ok(v.get(0).is(), "check array[0] type"); + is(v.get(0).get(), 1.0, "check array[0] value"); + ok(v.contains(1), "check contains array[1]"); + ok(v.get(1).is(), "check array[1] type"); + ok(v.get(1).get(), "check array[1] value"); + ok(v.contains(2), "check contains array[2]"); + ok(v.get(2).is(), "check array[2] type"); + is(v.get(2).get(), string("hello"), "check array[2] value"); + ok(!v.contains(3), "check not contains array[3]"); + } + + { + picojson::value v; + const char *s = "{ \"a\": true }"; + string err = picojson::parse(v, s, s + strlen(s)); + ok(err.empty(), "object no error"); + ok(v.is(), "object check type"); + is(v.get().size(), size_t(1), "check object size"); + ok(v.contains("a"), "check contains property"); + ok(v.get("a").is(), "check bool property exists"); + is(v.get("a").get(), true, "check bool property value"); + is(v.serialize(), string("{\"a\":true}"), "serialize object"); + ok(!v.contains("z"), "check not contains property"); + } + +#define TEST(json, msg) do { \ + picojson::value v; \ + const char *s = json; \ + string err = picojson::parse(v, s, s + strlen(s)); \ + is(err, string("syntax error at line " msg), msg); \ + } while (0) + TEST("falsoa", "1 near: oa"); + TEST("{]", "1 near: ]"); + TEST("\n\bbell", "2 near: bell"); + TEST("\"abc\nd\"", "1 near: "); +#undef TEST + + { + picojson::value v1, v2; + const char *s; + string err; + s = "{ \"b\": true, \"a\": [1,2,\"three\"], \"d\": 2 }"; + err = picojson::parse(v1, s, s + strlen(s)); + s = "{ \"d\": 2.0, \"b\": true, \"a\": [1,2,\"three\"] }"; + err = picojson::parse(v2, s, s + strlen(s)); + ok((v1 == v2), "check == operator in deep comparison"); + } + + { + picojson::value v1, v2; + const char *s; + string err; + s = "{ \"b\": true, \"a\": [1,2,\"three\"], \"d\": 2 }"; + err = picojson::parse(v1, s, s + strlen(s)); + s = "{ \"d\": 2.0, \"a\": [1,\"three\"], \"b\": true }"; + err = picojson::parse(v2, s, s + strlen(s)); + ok((v1 != v2), "check != operator for array in deep comparison"); + } + + { + picojson::value v1, v2; + const char *s; + string err; + s = "{ \"b\": true, \"a\": [1,2,\"three\"], \"d\": 2 }"; + err = picojson::parse(v1, s, s + strlen(s)); + s = "{ \"d\": 2.0, \"a\": [1,2,\"three\"], \"b\": false }"; + err = picojson::parse(v2, s, s + strlen(s)); + ok((v1 != v2), "check != operator for object in deep comparison"); + } + + { + picojson::value v1, v2; + const char *s; + string err; + s = "{ \"b\": true, \"a\": [1,2,\"three\"], \"d\": 2 }"; + err = picojson::parse(v1, s, s + strlen(s)); + picojson::object& o = v1.get(); + o.erase("b"); + picojson::array& a = o["a"].get(); + picojson::array::iterator i; + i = std::remove(a.begin(), a.end(), picojson::value(std::string("three"))); + a.erase(i, a.end()); + s = "{ \"a\": [1,2], \"d\": 2 }"; + err = picojson::parse(v2, s, s + strlen(s)); + ok((v1 == v2), "check erase()"); + } + + ok(picojson::value(3.0).serialize() == "3", + "integral number should be serialized as a integer"); + + { + const char* s = "{ \"a\": [1,2], \"d\": 2 }"; + picojson::null_parse_context ctx; + string err; + picojson::_parse(ctx, s, s + strlen(s), &err); + ok(err.empty(), "null_parse_context"); + } + + return success ? 0 : 1; +} + +#endif diff --git a/player.cpp b/player.cpp index 2140ce9edff48..00bf8df8aa5e1 100644 --- a/player.cpp +++ b/player.cpp @@ -12,6 +12,8 @@ #include #include +#include "name.h" + #if (defined _WIN32 || defined WINDOWS) #include "catacurse.h" #elif (defined __CYGWIN__) @@ -195,11 +197,8 @@ void player::normalize(game *g) } } -void player::pick_name() -{ - std::stringstream ss; - ss << random_first_name(male) << " " << random_last_name(); - name = ss.str(); +void player::pick_name() { + name = Name::generate(male); } void player::reset(game *g) @@ -4240,6 +4239,10 @@ bool player::takeoff(game *g, char let) return false; } +void player::use_wielded(game *g) { + use(g, weapon.invlet); +} + void player::use(game *g, char let) { item* used = &i_at(let); @@ -5048,43 +5051,3 @@ bool activity_is_suspendable(activity_type type) return false; return true; } - -std::string random_first_name(bool male) -{ - std::ifstream fin; - std::string name; - char buff[256]; - if (male) - fin.open("data/NAMES_MALE"); - else - fin.open("data/NAMES_FEMALE"); - if (!fin.is_open()) { - debugmsg("Could not open npc first names list (%s)", - (male ? "NAMES_MALE" : "NAMES_FEMALE")); - return ""; - } - int line = rng(1, NUM_FIRST_NAMES); - for (int i = 0; i < line; i++) - fin.getline(buff, 256); - name = buff; - fin.close(); - return name; -} - -std::string random_last_name() -{ - std::string lastname; - std::ifstream fin; - fin.open("data/NAMES_LAST"); - if (!fin.is_open()) { - debugmsg("Could not open npc last names list (NAMES_LAST)"); - return ""; - } - int line = rng(1, NUM_LAST_NAMES); - char buff[256]; - for (int i = 0; i < line; i++) - fin.getline(buff, 256); - lastname = buff; - fin.close(); - return lastname; -} diff --git a/player.h b/player.h index 56de61b449ad1..51489a9dace48 100644 --- a/player.h +++ b/player.h @@ -29,12 +29,6 @@ struct special_attack special_attack() { bash = 0; cut = 0; stab = 0; }; }; -#define NUM_FIRST_NAMES 100 -#define NUM_LAST_NAMES 100 - -std::string random_first_name(bool male); -std::string random_last_name(); - class player { public: player(); @@ -194,6 +188,7 @@ class player { bool wear_item(game *g, item *to_wear); bool takeoff(game *g, char let);// Take off item; returns false on fail void use(game *g, char let); // Use a tool + void use_wielded(game *g); bool install_bionics(game *g, it_bionic* type); // Install bionics void read(game *g, char let); // Read a book void try_to_sleep(game *g); // '$' command; adds DIS_LYING_DOWN