[Date Prev][Date Next] [Thread Prev][Thread Next] [Date Index] [Thread Index]

Re: RFCorr: boohu

Adam Borowski wrote on Sun, Aug 05:
> I'm packaging a roguelike game called boohu.  The game itself is good, but
> the grammar of messages is atrocious -- to the tune of >50% requiring a
> correction.
> However, while I can fix grammar myself, in many cases I'm unsure what
> wording would be best from a stylistic point of view.
> Thus, it would be great if someone could:
>   git clone https://github.com/anaseto/boohu
> then search for all lines containing "Print", correct them, and provide a

After most of a month spent either off the Internet or away from
keyboard I'm finally back on a machine where I can do this!

> patch (either as a pull request directly to upstream, or for me to apply
> in our packaging then forward).

Unfortunately I have no idea how to do this with git, but I haven't
really got to that stage anyway.  Here's commented "grep -rn Print"
output for now - but I notice it misses quite a lot of text that's
emitted via Sprintf, Error, descriptions and so on.

draw.go:346:		g.Print(DoNothing)
draw.go:783:		g.Print("Do you really want to dive in optional depths? [y/N]")

A running theme later on: the lines most in need of fixing are the
ones I can't immediately fix because I'm not sure I understand them.
Does this perhaps mean something like "Do you really want to continue
down to optional dungeon levels?"

draw.go:874:			g.PrintfStyled("Error: %v", logError, err)
draw.go:875:			g.PrintStyled("Could not save game.", logError)
draw.go:882:			g.PrintStyled("Error writing dump to file.", logError)
draw.go:886:				g.Printf("Dump written to %s.", filepath.Join(dataDir, "dump"))
draw.go:888:				g.Print("Dump written.")

(There's no sign of error messages going to stderr...)

draw.go:1261:		g.Print("You cannot choose an unexplored cell for exclusion.")
draw.go:1273:			g.Print(err.Error())
draw.go:1389:			g.PrintfStyled("Error: %v", logError, err)
draw.go:1390:			g.PrintStyled("Could not save game.", logError)
draw.go:1478:			g.Print(err.Error())
draw.go:2471:				g.Printf("You cannot rebind “%c”.", r)
draw.go:2488:				g.Print(err.Error())
draw.go:2497:				g.Print(err.Error())
draw.go:2944:			g.Print(err.Error())
draw.go:2955:			g.Print(err.Error())
draw.go:2961:			g.Print(err.Error())
draw.go:3038:	g.Print("You die... --press esc or space to continue--")
draw.go:3049:		g.PrintfStyled("Error removing saved file: %v", logError, err)

(If this is talking about a game-save rather than an arbitrary
file-deletion then for consistency it might be better as "save file".)

draw.go:3052:		g.Print("You escape by the magic stairs! **WIZARD** --press esc or space to continue--")
draw.go:3054:		g.Print("You escape by the magic stairs! You win. --press esc or space to continue--")
draw.go:3070:	g.PrintStyled("*** CRITICAL HP WARNING *** --press esc or space to continue--", logCritic)

Oh, *that* sort of HP warning.  For a moment I was having HP printer

draw.go:3073:	g.Print("Ok. Be careful, then.")

"Ok" should be "OK" or "Okay".

draw.go:3159:	g.Print("Do you really want to quit without saving? [y/N]")
draw.go:3165:			g.PrintfStyled("Error removing save file: %v ——press any key to quit——", logError, err)

Inconsistent use of fancy em-dashes instead of ASCII hyphens.

draw.go:3170:		g.Print(DoNothing)
draw.go:3176:	g.Print("Do you really want to enter wizard mode (no return)? [y/N]")
draw.go:3193:			g.Print(err.Error())
save.go:36:		g.Print(err.Error())
save.go:42:		g.Print(err.Error())
save.go:47:		g.Print(err.Error())
save.go:86:		g.Print(err.Error())
save.go:92:		g.Print(err.Error())
save.go:97:		g.Print(err.Error())
main.go:30:		fmt.Println(Version)
main.go:59:		g.PrintfStyled("Error: %v", logError, err)
main.go:60:		g.PrintStyled("Could not load saved game… starting new game.", logError)
main.go:64:		g.Print("Error loading config file.")
rods.go:191:	g.StoryPrintf("You evoked your %s.", r)

If this is talking about activating a magic item, I'll mention that
although this usage has become widespread in fantasy games, it started
as a misunderstanding.  Originally, you didn't evoke a wand (or
whatever), you used a wand to evoke a magical effect.  In normal
English, "evoke" is mostly just a poetic synonym for "remind people

rods.go:227:		g.Print("You could not blink.")
rods.go:238:	g.Print("You blink away.")

What determines whether these messages are going to be present or
past tense?

rods.go:258:	g.Print("A sleeping ball emerges straight from the rod.")

What does this mean?  If it's talking about some sort of sedative-bolt
then it needs renaming, because a "sleeping ball" sounds more like a
combined masked ball and sleepover.  And in general, here and below,
"straight from" needs to be "straight out of".  Mind you, "emerges
straight out of the rod" is still a rather odd way to put it; I'd have
expected something more like "the rod emits a bolt of sleep."

rods.go:280:	g.Print("Whoosh! A fire bolt emerges straight from the rod.")
rods.go:295:			g.Printf("%s is killed by the bolt.", mons.Kind.Indefinite(true))
rods.go:310:	g.Printf("A fireball emerges straight from the rod... %s", g.ExplosionSound())
rods.go:326:			g.Printf("%s is killed by the fireball.", mons.Kind.Indefinite(true))
rods.go:344:	g.Print("Whoosh! Lightning emerges straight from the rod.")
rods.go:374:			g.Printf("%s is killed by lightning.", mons.Kind.Indefinite(true))
rods.go:404:	g.Print("You are surrounded by a dense fog.")
rods.go:439:	g.Print("You see the wall disintegrate with a crash.")
rods.go:456:	g.Printf("%s The wall disappeared.", g.CrackSound())
rods.go:462:	//g.Print("You see an explosion around the wall.")

Is that "you see around the wall to somewhere where there's an
explosion" or "behold! the wall is surrounded by an explosion"
(whatever that's meant to look like)?  If the latter, I'd be more
likely to say something like "the wall is the centre of an explosion"
(or for this game, "center").

rods.go:478:			g.Printf("%s is killed by the explosion.", mons.Kind.Indefinite(true))
rods.go:492:	g.Printf("You see a wall appear from nothing.")
rods.go:524:	g.Printf("You swap positions with the %s.", mons.Kind)
items.go:26:	g.StoryPrintf("You used %s.", Indefinite(c.String(), false))
items.go:204:	g.Printf("You quaff a %s. You feel unstable.", TeleportationPotion)

Or indeed inadequately localised.

items.go:214:	g.Printf("You quaff a %s. You feel a sudden urge to kill things.", BerserkPotion)
items.go:225:	g.Printf("You quaff a %s (%d -> %d).", HealWoundsPotion, hp, g.Player.HP)
items.go:235:	g.Printf("You quaff the %s (%d -> %d).", MagicPotion, mp, g.Player.MP)

What makes mana potions more definite than health potions?

items.go:247:	g.Printf("You quaff the %s. You fall through the ground.", DescentPotion)
items.go:249:	g.StoryPrint("You descended deeper in the dungeon.")

Probably s/in/into/, here and elsewhere.

items.go:265:	g.Printf("You quaff the %s. You feel speedy and agile.", SwiftnessPotion)
items.go:275:	g.Printf("You quaff the %s. You feel like an earth dragon.", DigPotion)
items.go:288:	g.Printf("You quaff the %s. You feel like dancing.", SwapPotion)

Note that "feel like dancing" means "want to dance", not "feel as if
you are dancing" (or "good at dancing").  If it lets you swap places
with attackers maybe it should be something like "You feel

items.go:298:	g.Printf("You quaff the %s. You feel surrounded by shadows.", ShadowsPotion)
items.go:309:	g.Printf("You quaff the %s. You feel rooted to the ground.", LignificationPotion)
items.go:341:	g.Printf("You quaff the %s. You feel wiser.", MagicMappingPotion)

(Whereas in fact you're merely better informed, but I dare say if it
*was* a potion of wisdom it would make adventurers feel like reckless

items.go:351:	g.Printf("You quaff the %s. You perceive monsters' dreams.", DreamPotion)
items.go:369:	g.Printf("You quaff the %s. You feel surrounded by temporal walls.", WallPotion)

Does this really mean walls of (or pertaining to) time?

items.go:381:	g.Printf("You quaff the %s. You blink.", CBlinkPotion)
items.go:485:			g.PrintfStyled("Your %s hits the %s (%d dmg), who appears confused.", logPlayerHit, ConfusingDart, mons.Kind, attack)
items.go:489:			g.PrintfStyled("Your %s kills the %s.", logPlayerHit, ConfusingDart, mons.Kind)
items.go:494:		g.Printf("Your %s missed the %s.", ConfusingDart, mons.Kind)
items.go:506:	g.Printf("You throw the explosive magara... %s", g.ExplosionSound())
items.go:554:	g.Print("You throw the night magara… Clouds come out of it.")

Does something somewhere explain what a magara is?  If not, players
are going to have trouble visualising things like this.

items.go:617:		g.StoryPrintf("You found and put on %s.", Indefinite(ar.String(), false))
items.go:620:	g.Printf("You put the %s on and leave your %s.", ar, oar)
items.go:729:		g.StoryPrintf("You found and took %s.", Indefinite(wp.String(), false))
items.go:732:	g.Printf("You take the %s and leave your %s.", wp, owp)
items.go:734:		g.PrintfStyled("♫ ♪ … Oh, you're there, let's fight our way out!", logSpecial)

Is "Oh, you're there" meant to be "Oh, there you are"?

items.go:900:		g.StoryPrintf("You found and put on %s.", Indefinite(sh.String(), false))
items.go:905:		g.Printf("You put the %s on and leave your %s.", sh, osh)
items.go:908:		g.Printf("You put the %s on.", sh)
events.go:118:			g.Print("Lignification prevented teleportation.")
events.go:126:		g.PrintStyled("You are no longer berserk.", logStatusEnd)
events.go:133:			g.PrintStyled("You feel no longer slow.", logStatusEnd)
events.go:137:		g.PrintStyled("You feel no longer exhausted.", logStatusEnd)
events.go:143:			g.PrintStyled("You feel no longer speedy.", logStatusEnd)
events.go:149:			g.PrintStyled("You feel no longer agile.", logStatusEnd)
events.go:156:			g.PrintStyled("You feel no longer attached to the ground.", logStatusEnd)
events.go:160:		g.PrintStyled("You feel no longer confused.", logStatusEnd)
events.go:164:		g.PrintStyled("You feel no longer sick.", logStatusEnd)

For all of the above, "feel no longer" would be more natural as "no
longer feel".

events.go:168:		g.PrintStyled("You manage to free your shield from the projectile.", logStatusEnd)

That sounds as if you're buried underneath it or something; I suspect
I'm meant to be imagining a spear weighing down your shield, in which
case say "You manage to dislodge the projectile from your shield."

events.go:174:			g.PrintStyled("Your equipment is now free from acid.", logStatusEnd)
events.go:180:			g.PrintStyled("You feel no longer like an earth dragon.", logStatusEnd)

As above, "no longer feel like".  (Do earth-wyrms feel slimy?)

events.go:186:			g.PrintStyled("You feel no longer dancing.", logStatusEnd)

This has dropped a "like"; "You no longer feel light-footed."

events.go:192:			g.PrintStyled("Shadows leaved you.", logStatusEnd)

The past tense of "leave" is "left", but probably this should be "The
shadows leave you."

events.go:203:			g.PrintStyled("You feel no longer slaying.", logStatusEnd)

s/feel no longer/no no longer feel/g; but "slaying" isn't a feeling.

events.go:240:			g.Printf("The %s is no longer confused.", mons.Kind)
events.go:328:		g.Print("The night clouds make you feel sleepy.")

Is it in fact talking about nocturnal weather or does something
produce magical zones of night-ness?  If the latter, maybe "The clouds
of night".

events.go:348:			g.PrintfStyled("%s is killed by the fire.", logPlayerHit, mons.Kind.Definite(true))
events.go:360:		g.PrintfStyled("The fire burns you (%d dmg).", logMonsterHit, damage)
events.go:383:		g.Print("The door vanishes in flames.")
ansi.go:39:		fmt.Println(Version)
ansi.go:82:		g.Print("Error loading saved game… starting new game.")
ansi.go:86:		g.Print("Error loading config file.")
ansi.go:352:		if unicode.IsPrint(in.r) {
termbox.go:255:			if unicode.IsPrint(tev.Ch) {
boohu.6:53:Print version number.
log.go:32:func (g *game) Print(s string) {
log.go:34:	g.PrintEntry(e)
log.go:37:func (g *game) PrintStyled(s string, style logStyle) {
log.go:39:	g.PrintEntry(e)
log.go:42:func (g *game) Printf(format string, a ...interface{}) {
log.go:44:	g.PrintEntry(e)
log.go:47:func (g *game) PrintfStyled(format string, style logStyle, a ...interface{}) {
log.go:49:	g.PrintEntry(e)
log.go:52:func (g *game) PrintEntry(e logEntry) {
log.go:71:func (g *game) StoryPrint(s string) {
log.go:75:func (g *game) StoryPrintf(format string, a ...interface{}) {
los.go:91:		g.Print("You stop exploring.")
los.go:93:		g.Print("You stop.")
los.go:95:		g.Print("You stop.")
los.go:103:		g.Print("You could not sleep.")
los.go:125:			g.Printf("You see %s (%v).", mons.Kind.Indefinite(false), mons.State)
los.go:127:				g.StoryPrint(mons.Kind.SeenStoryText())
los.go:139:				g.Printf("You %s %d %s.", see, c.Quantity, c.Consumable.Plural())
los.go:141:				g.Printf("You %s %s.", see, Indefinite(c.Consumable.String(), false))
los.go:145:			g.Printf("You %s stairs.", see)
los.go:148:			g.Printf("You %s %s.", see, Indefinite(eq.String(), false))
los.go:151:			g.Printf("You %s %s.", see, Indefinite(rod.String(), false))
los.go:159:			g.Printf("There is no more a wall there.")

s/no more/no longer/

los.go:164:			g.Printf("There are flames there.")
los.go:254:				g.Print("You heared some footsteps.")

The past tense of "hear" is "heard", but why not plain "You hear

player.go:152:			g.Print(err.Error())
player.go:197:		g.Print(err.Error())
player.go:240:			g.PrintStyled("You feel a little bored, your health could decline.", logCritic)

Strictly speaking that's a comma-splice (and should be either a
semicolon or full stop).  But if you're so bored it reduces your
hitpoints then maybe it should just say "You feel bored sick."

player.go:247:			g.PrintStyled("You feel unhealthy.", logCritic)
player.go:327:		g.Print("You feel yourself teleported away.")

Is this a description of what's really happening or just what it feels
like?  If the former, just say "You are teleported away."

player.go:332:		g.Print("Something went wrong with the teleportation.")
player.go:341:			g.Print("You pick up a simella.")
player.go:343:			g.Printf("You pick up %d simellas.", g.Simellas[pos])
player.go:353:			g.Printf("You take %d %s.", c.Quantity, c.Consumable.Plural())
player.go:355:			g.Printf("You take %s.", Indefinite(c.Consumable.String(), false))
player.go:362:		g.Printf("You take a %s.", r)
player.go:363:		g.StoryPrintf("You found and took a %s.", r)
player.go:366:		g.Printf("You stand over %s.", Indefinite(eq.String(), false))

All of these "stand" messages should perhaps say "You are standing".

player.go:368:		g.Print("You stand over stairs.")

That sounds awkward.  If you're in the same space as a stairway that
might lead either up or down, I'd suggest "You are standing on some
stairs."  (Or maybe "in/on a stairway", or "on a staircase", but
probably not "in a stairwell".)

player.go:370:		g.Print("You stand at the door.")
player.go:401:			g.Print(g.CrackSound())
player.go:479:	g.Print("You feel an energy burst and smoking coming out from you.")

Does this mean you feel two things emerging from yourself, or is the
energy burst inbound?  Either way, "smoking" is prohibited.  I suspect
it should be something like "You feel a burst of fire and smoke coming
out of you."

player.go:485:	g.Print("Your equipment is corroded.")
player.go:492:		g.Print("You feel confused.")
js.go:41:		g.Printf("Error loading saved game… starting new game. (%v)", err)
js.go:45:		g.Print("Error loading config file.")
js.go:609:		if unicode.IsPrint(r) {
js.go:755:		g.Printf("Invalid key: “%s”.", in.key)
game.go:477:		g.Print("You're in Hareka's Underground searching for medicinal simellas. Good luck!")
game.go:478:		g.PrintStyled("► Press ? for help on keys or use the mouse and [buttons].", logSpecial)
game.go:481:		g.PrintStyled("You feel magic in the air. A first way out is close!", logSpecial)
game.go:483:		g.PrintStyled("If rumors are true, you reached the bottom!", logSpecial)

Does this mean you once did reach (what might be) the bottom or that
you are currently at that level?  If the latter, "have reached".

game.go:490:		g.PrintStyled("You hear some faint music… ♫ larilon, larila ♫ ♪", logSpecial)
game.go:783:		g.StoryPrint("You escaped!")
game.go:788:	g.Print("You descend deeper in the dungeon.")

Probably "into".

game.go:789:	g.StoryPrint("You descended deeper in the dungeon.")

Ditto, but why the tense difference?

game.go:802:	g.PrintStyled("You are now in wizard mode and cannot obtain winner status.", logSpecial)
game.go:832:	g.PrintStyled("You feel fresh again. Some monsters might have awaken.", logStatusEnd)

Morphology error - "have awoken".

game.go:851:			g.Print("You could not sleep.")
game.go:857:			g.Print("Stopping, then.")
game.go:867:					g.Print("You finished exploring.")
game.go:878:				g.Print("You finished exploring.")
game.go:880:				g.Print("You could not reach safely some places.")

Awkward adverb placement - probably "You could not safely reach some

game.go:885:					g.Print(err.Error())
game.go:918:					g.PrintfStyled("Error removing save file: %v", logError, err.Error())
utils.go:24:		log.Println(err, ":", n)
tcell.go:264:			if unicode.IsPrint(r) {
monster.go:1434:		g.Print("Marevor pushes you through a monolith.")

*Through* a monolith?  Well, okay.

monster.go:1435:		g.StoryPrint("Marevor pushed you through a monolith.")
monster.go:1438:		g.Print("Marevor inadvertently goes into a monolith.")
monster.go:1469:		g.Printf("%s teleports away.", m.Kind.Definite(true))
monster.go:1482:			g.Printf("%s (%v) comes into view.", m.Kind.Indefinite(true), m.State)
monster.go:1508:				g.Print("Marevor makes some strange gestures.")
monster.go:1645:				g.Printf("%s You hear an earth-breaking noise.", g.CrackSound())

The only context in which it's normal to talk about "breaking" earth
is at the start of some farming/building work.  Maybe

monster.go:1753:			g.Printf("Clang! You block %s's attack.", m.Kind.Definite(false))
monster.go:1768:		g.PrintfStyled("%s hits you (%d dmg).%s", logMonsterHit, m.Kind.Definite(true), attack, sclang)
monster.go:1776:			g.Printf("You release a confusing gas on the %s.", m.Kind)

Assuming this is some sort of cloud of bewilderment I'd say "against"
rather than "on".

monster.go:1783:		g.Printf("%s misses you.", m.Kind.Definite(true))
monster.go:1807:			g.Print("You feel a sudden urge to kill things.")
monster.go:1817:			g.Print("The yack pushes you.")

Is that a *yak* or some sort of imaginary monster that just *sounds*
like a yak?  Do you get a side-quest that involves shaving one?

monster.go:1826:		g.Print("The flying milfid makes you swap positions.")

There's a flying *what* now?

monster.go:1908:		g.PrintfStyled("%s throws a bolt of torment at you.", logMonsterHit, m.Kind.Definite(true))
monster.go:1912:		g.Printf("You block the %s's bolt of torment.", m.Kind)
monster.go:1961:		g.PrintfStyled("%s throws a rock at you (%d dmg).%s", logMonsterHit, m.Kind.Definite(true), attack, sclang)
monster.go:1974:		g.Printf("You block %s's rock. Clang!", m.Kind.Indefinite(false))
monster.go:1984:		g.Printf("You dodge %s's rock.", m.Kind.Indefinite(false))
monster.go:2021:		g.Printf("%s throws %s at you (%d dmg).%s", m.Kind.Definite(true), Indefinite("javelin", false), attack, sclang)
monster.go:2026:			g.Printf("You block %s's %s. Clang!", m.Kind.Indefinite(false), "javelin")
monster.go:2033:			g.Printf("%s's %s gets fixed on your shield.", m.Kind.Indefinite(true), "javelin")

Should that be "embedded in"?

monster.go:2039:		g.Printf("You dodge %s's %s.", m.Kind.Indefinite(false), "javelin")
monster.go:2069:		g.Printf("%s throws acid at you (%d dmg).", m.Kind.Definite(true), attack)
monster.go:2079:		g.Printf("You block %s's acid projectile.", m.Kind.Indefinite(false))
monster.go:2087:		g.Printf("You dodge %s's acid projectile.", m.Kind.Indefinite(false))
monster.go:2100:	g.PrintfStyled("%s uses energies to lure you.", logMonsterHit, m.Kind.Definite(true))


monster.go:2146:	g.Printf("%s absorbs your mana.", m.Kind.Definite(true))
monster.go:2156:	g.Printf("%s %s blows with a noisy pop.", g.ExplosionSound(), m.Kind.Definite(true))

Oh, wait, it blows *up*?  It took me a while to realise you weren't
getting orcs blowing raspberries at you or something - "noisy pop" is
a bit underwhelming.  How about "explodes with a loud boom"?

monster.go:2197:			g.Printf("%s awakes.", m.Kind.Definite(true))
monster.go:2200:			g.Printf("%s barks.", m.Kind.Definite(true))
monster.go:2274:		g.Printf("%s awakes.", m.Kind.Definite(true))
monster.go:2277:		g.Printf("%s notices you.", m.Kind.Definite(true))
monster.go:2280:		g.Printf("%s barks.", m.Kind.Definite(true))
aptitude.go:74:		g.PrintStyled("Hm… You already have that aptitude. "+ap.String(), logError)
aptitude.go:78:	g.PrintStyled("You feel different. "+ap.String(), logSpecial)
combat.go:42:		g.StoryPrintf("Critical HP: %d (hit by %s)", g.Player.HP, m.Kind.Indefinite(false))
combat.go:125:			g.PrintfStyled("Frundis glows… %s appears confused.", logPlayerHit, mons.Kind.Definite(false))
combat.go:177:			g.Print("Your sword insurges you to kill things.")

Even insurgents don't go around insurging people; maybe you just mean

combat.go:352:			g.PrintfStyled("You hit %s (%d dmg).%s", logPlayerHit, mons.Kind.Definite(false), attack, sclang)
combat.go:355:			g.PrintfStyled("You kill %s (%d dmg).%s", logPlayerHit, mons.Kind.Definite(false), attack, sclang)
combat.go:362:			g.Print("The brizzia's corpse releases a nauseous gas. You feel sick.")

Pedantically, "nauseous" can be ambiguous between causing and
suffering nausea; "nauseating" might be safer.

combat.go:366:		g.Printf("You miss %s.", mons.Kind.Definite(false))
combat.go:383:		g.StoryPrintf("You killed %s.", mons.Kind.Indefinite(false))
combat.go:424:				g.Printf("%s Blocking sound breaks a wall.", g.CrackSound())

I don't understand this.

combat.go:453:			g.Printf("%s is repelled away.", m.Kind.Definite(true))

There's no need for the "away".

combat.go:461:			g.Printf("%s appears confused.", m.Kind.Definite(true))

JBR	with qualifications in linguistics, experience as a Debian
	sysadmin, and probably no clue about this particular package

Reply to: