We are truly excited to announce that Fourtex Jugo will be leaving Steam Early Access, and launching fully and in its complete form on April 13th!

Jugo is unlike any puzzle game you've played before:

• Various play modes allow self-selection of difficulty on a particular level. On each level, you can shoot for 1, 2 or 3 stars, each getting increasingly more difficult, or you can just shoot for the high score.

• The AI is, along with every other aspect of play, 100% deterministic. So, you can plan accordingly, but plan you must, or risk your pie getting eaten.

• The rules are simple combine the particles to achieve the highest score possible. But, doing so while avoiding the claws will be a satisfying challenge.

Lorin has put together a pair of developer Let's Play videos for players to reference ahead of next week's release as well:

Fourtex Jugo Lets Play with the Game Designer Ep #1 YouTube

Fourtex Jugo Lets Play with the Game Designer Ep #2 YouTube

While Fourtex Jugo will be essentially complete after next week's launch, this will be far from the end. The game will keep on getting better and richer for as long as possible. There are many new ideas, and puzzles that we hope to bring about in later updates.

Look out for more info over the coming weeks -- thank you so much for your support and feedback during early access!

It may be premature to write an extensive history of Jugo, but for those interested in the look and feel of the game and how they have changed and may change again, here are… pictures. Whee!

Our current prototype had two primary paths of evolution: the game-play itself, and the artwork.

Our talented artist Steve came up with many cool layout versions while we pondered what the game was supposed to do. Several had a space-based them, with a dark background that soon became filled with space-stuff like a nebula, or more than one nebula, i.e. nebulae. And claws.

I think we all really liked the stone backgrounds. They were abandoned due to technical reasons, primarily the time element for making the graphics and any animations work correctly. Now that game-play is fully worked out, however, there is a chance we may all get together and say...let there be rock.

The last screenshots show various early versions of game play, which at one time was apparently pretty complicated. Still, there are probably one or two different versions that might be fun, so we are hoping some day we have a chance and a reason to explore some alternate play modes.

Jugo is now trying to make its way through the Greenlight process on Steam, so we encourage any of you who haven’t done so yet to head over there and give Jugo a vote.

A type-safe event system for Unity based on the event listener pattern was originally described by Will Miller here http://www.willrmiller.com/?p=87. We use this pattern at Salty Dog. We made a few minor modifications, added some unit tests and example code, and published it as the asset EventManager. The full MIT licensed source code is located here https://github.com/robertwahler/EventManager.

This pattern is useful when you want to keep your codebase loosely coupled. Publishers and subscribers don't need to know anything about each other. This is not a solution for exposing callbacks in the Unity Editor, Unity's own EventSystem may be more appropriate for that use case.

Features

• Loosely coupled
• Type-safe
• Avoids breaking changes when new event parameters are added

Example Usage

The original article does a good job of explaining the purpose and the inner workings of this event system. This usage example, Colors Clicker (shown in screenshot above) will walk through a simple use case. The example scene, full code, and installation instructions are available in the EventManager repository.

Create Events

Events are straight-up C# classes based on SDD.Events.Event

namespace SDD.Events {

  /// <summary>
  /// Base event for all EventManager events.
  /// </summary>
  public class Event {
  }
}

View on GitHub

The Colors.Events.ButtonClickEvent descends from SDD.Events.Event and has a single simple property reference to Colors.ButtonHandler. Events can have zero to as many properties as needed. This simple flexibility permits easily adding properties to events as a project evolves without breaking existing functionality.

namespace Colors.Events {

  /// <summary>
  /// Raised event signals a button was clicked
  /// </summary>
  public class ButtonClickEvent : SDD.Events.Event {

    public ButtonHandler ButtonHandler { get; set; }

    /// <summary>
    /// Return a string
    /// </summary>
    public override string ToString(){
      return string.Format("{0}, ButtonHandler {1}", base.ToString(), ButtonHandler);
    }

  }
}

View on GitHub

Implement IEventHandler

EventManager provides a generic interface to allow MonoBehaviours to add and remove listener delegates.

namespace SDD.Events {

  /// <summary>
  ///  Interface for event handlers
  /// </summary>
  public interface IEventHandler {

    /// <summary>
    /// Subscribe to events
    ///
    /// @example
    ///   Events.AddListener<MoveResolvedEvent>(OnMoveResolved);
    ///     or
    ///   EventManager.OnSetRule += OnSetRule;
    /// </summary>
    void SubscribeEvents();

    /// <summary>
    /// Unsubscribe from events
    ///
    /// @example
    ///   Events.RemoveListener<MoveResolvedEvent>(OnMoveResolved);
    ///     or
    ///   EventManager.OnSetRule -= OnSetRule;
    /// </summary>
    void UnsubscribeEvents();

  }
}

View on GitHub

Color Clicker EventHandler Abstract Class

This class is used as a base class for all event event handlers in the project. The implementation ensures event listeners are added and removed appropriately when MonoBehviours are added and destoyed.

using UnityEngine;  
using SDD.Events;

namespace Colors.Events {

  /// <summary>
  /// Event handler
  /// </summary>
  public abstract class EventHandler : MonoBehaviour, IEventHandler {

    /// <summary>
    /// Subscribe to events
    ///
    /// @example
    ///   EventManager.Instance.AddListener<MoveResolvedEvent>(OnMoveResolved);
    /// </summary>
    public abstract void SubscribeEvents();

    /// <summary>
    /// Unsubscribe from events
    ///
    /// @example
    ///   EventManager.Instance.RemoveListener<MoveResolvedEvent>(OnMoveResolved);
    /// </summary>
    public abstract void UnsubscribeEvents();

    protected virtual void OnEnable() {
      SubscribeEvents();
    }

    protected virtual void OnDisable() {
      UnsubscribeEvents();
    }

  }
}

View on GitHub

Concrete EventHandler Implementation

This header text handler responds to events by displaying text at the top of the screen. See screenshot above.

using UnityEngine;  
using UnityEngine.UI;  
using SDD.Events;

using Colors.Events;

namespace Colors {

  /// <summary>
  /// Header text handler
  /// </summary>
  public class HeaderText : EventHandler {

    /// <summary>
    /// Header text. Assign in IDE.
    /// </summary>
    public Text text;

    public override void SubscribeEvents() {
      Debug.Log(string.Format("HeaderText.SubscribeEvents() name {0}", name));

      EventManager.Instance.AddListener<ButtonClickEvent>(OnButtonClickEvent);
      EventManager.Instance.AddListener<ButtonRemovedEvent>(OnButtonRemovedEvent);
    }

    public override void UnsubscribeEvents() {
      Debug.Log(string.Format("HeaderText.UnsubscribeEvents() name {0}", name));

      EventManager.Instance.RemoveListener<ButtonClickEvent>(OnButtonClickEvent);
      EventManager.Instance.RemoveListener<ButtonRemovedEvent>(OnButtonRemovedEvent);
    }

    /// <summary>
    /// A button in the scene was clicked
    /// </summary>
    public void OnButtonClickEvent(ButtonClickEvent e) {
      Debug.Log(string.Format("HeaderText.OnClick({0})", e));

      string caption = string.Format("{0} '{1}' was clicked.\nEventManager.DelegateLookupCount is {2}", e.ButtonHandler.kind, e.ButtonHandler.name, EventManager.Instance.DelegateLookupCount);
      text.text = caption;
    }

    /// <summary>
    /// A button in the scene was destroyed
    /// </summary>
    public void OnButtonRemovedEvent(ButtonRemovedEvent e) {
      Debug.Log(string.Format("HeaderText.OnButtonRemoved({0})", e));

      string caption = string.Format("'{0}' was removed.", e.Name);
      text.text = caption;
    }

  }
}

View on GitHub

Raising Events

Events can be raised anywhere without knowing any details of the listening behaviours. Here is a snippet from the Unity EventSystem OnClick handler for the big colored buttons. This snippet creates the ButtonClickEvent each time it raises the event. This is fine for seldom raised events but can create a garbage collection issue if the event is raised often. Create a reference cache to prevent memory allocations after initialization. See the field buttonRemovedEvent for an example of zero allocations after initialization.

/// <summary>
/// OnClick handler for the button on this specific GameObject
/// </summary>
public void OnClick() {  
  Debug.Log(string.Format("ButtonHandler.OnClick() name {0}", name));

  EventManager.Instance.Raise(new ButtonClickEvent(){ ButtonHandler=this });
}

View on GitHub

Simple and Flexible

There you have it. Thanks for reading! We think EventManager is simple and flexible and makes event system maintenance and trouble-shooting about as easy as it gets in a fully decoupled architecture.

If you have appreciated this article or would like to see the games we are creating with this event system, please visit our Steam Greenlight page.

Our released game Fourtex Zen also uses this event system.

Salty is beside himself with the excitement! Fourtex Jugo is on Steam Greenlight. Please visit our Steam Greenlight page and let us know what you think.

Screenshots

Level 1

Start screen

Level 3

Level 4

In-game menu

Editing text layers in Gimp is hit or miss if the font isn’t installed. You can tell it isn’t installed because when you click on the text with the text tool, no font name or size is listed.

Find the font

Requires the GNU CLI utilities.

strings jugo-artwork-alt.xcf | grep font  

Install the font before opening the XCF file.

Give your layout groups some smarts. This DynamicLayoutGroup group switches orientation automatically between landscape and portrait layouts. It acts like a VerticalLayoutGroup (screenshot above) or a HorizontalLayoutGroup (screenshot below) depending the current aspect ratio of the screen.

The Why

These screenshots are from an upcoming 2.0 update to Fourtex Zen. The game shipped with a fixed landscape orientation. We recently moved to Unity 5 and decided that updating Fourtex Zen would be a good way to learn the new UI system. We wanted the game playable regardless of screen orientation. The poem panels stack the poetry text in portrait and place it side-by-side in landscape (there are 64 poems given as in-game rewards).

The Code

The DynamicLayoutGroup class inherits directly from the Unity 5 HorizontalOrVerticalLayoutGroup base class and provides a simple mechanism to determine screen orientation and shift its layout accordingly. It can be used anywhere you would normally use a VerticalLayoutGroup or HorizontalLayoutGroup.

using UnityEngine;  
using UnityEngine.UI;  
using UnityEngine.EventSystems;  
using System.Collections;  
using System.Collections.Generic;

namespace SDD.UI {

  /// <summary>
  /// Layout group switches orientation automatically between landscape and
  /// portrait layouts so it either acts like a VerticalLayoutGroup or a
  /// HorizontalLayoutGroup.
  /// </summary>
  [AddComponentMenu("Layout/Dynamic Layout Group", 150)]
  public class DynamicLayoutGroup : HorizontalOrVerticalLayoutGroup {

    /// <summary>
    /// When is the layout vertical? In portrait or landscape?
    /// </summary>
    [SerializeField]
    public ScreenOrientation verticalWhen = ScreenOrientation.Portrait;

    public bool IsVertical { get { return GetIsVertical(); }}

    private bool GetIsVertical() {
      bool isVertical;

      if (UnityEngine.Screen.width > UnityEngine.Screen.height) {
        //orientation = ScreenOrientation.Landscape;
        isVertical = (verticalWhen == ScreenOrientation.Landscape) ? true : false;
      }
      else {
        //orientation = ScreenOrientation.Portrait;
        isVertical = (verticalWhen == ScreenOrientation.Portrait) ? true : false;
      }

      //Log.Debug(string.Format("DynamicLayoutGroup.OnRectTransformDimensionsChange() isVertical={0}a, ID={1}", isVertical, GetInstanceID()));
      return isVertical;
    }

    public override void CalculateLayoutInputHorizontal() {
      //Log.Debug(string.Format("DynamicLayoutGroup.CalculateLayoutInputHorizontal() IsVertical={0}, ID={1}", IsVertical, GetInstanceID()));

      base.CalculateLayoutInputHorizontal();
      CalcAlongAxis(0, isVertical: IsVertical);
    }

    public override void CalculateLayoutInputVertical() {
      //Log.Debug(string.Format("DynamicLayoutGroup.CalculateLayoutInputVertical() IsVertical={0}, ID={1}", IsVertical, GetInstanceID()));

      CalcAlongAxis(1, isVertical: IsVertical);
    }

    public override void SetLayoutHorizontal() {
      //Log.Debug(string.Format("DynamicLayoutGroup.SetLayoutHorizontal() IsVertical={0}, ID={1}", IsVertical, GetInstanceID()));

      SetChildrenAlongAxis(0, isVertical: IsVertical);
    }

    public override void SetLayoutVertical() {
      //Log.Debug(string.Format("DynamicLayoutGroup.SetLayoutVertical() IsVertical={0}, ID={1}", IsVertical, GetInstanceID()));

      SetChildrenAlongAxis(1, isVertical: IsVertical);
    }
  }
}

using UnityEditor;  
using UnityEngine;  
using UnityEngine.UI;

namespace SDD.UI {

  /// <summary>
  /// Override the Unity UI custom editor for HorizontalOrVerticalLayoutGroup
  /// and do exactly nothing. The only purpose of this class is to expose the
  /// public ```VerticalWhen```. The inherited editor prevents editing new
  /// publics in descendant classes without doing a full widget layout here
  /// (too much work!).
  /// </summary>
  /// <remarks>
  /// Place in ```Editor``` folder
  /// </remarks>
  [CustomEditor(typeof(SDD.UI.DynamicLayoutGroup), true)]
  [CanEditMultipleObjects]
  public class DynamicLayoutGroupEditor : UnityEditor.Editor {
  }
}

namespace SDD {

  /// <summary>
  /// Orientation of the screen regardless of which way is up
  /// </summary>
  public enum ScreenOrientation {
    Landscape,
    Portrait
  }

GitHub Gist

Fourtex Jugo is strategy-based single-player puzzler with two players, because Jugo is always there, watching and waiting for your mistake.

Each level has a target score which may be relatively easy to beat, or not. Some are quite difficult. Can you beat them all? Can you play a perfect game, when Jugo is always ready to capitalize on any opportunity to ruin your perfect game?

Pie and Noms

In Fourtex Jugo you progress through a level by combining the three particle types with each other to create higher-value particles, or to create void. Number particles combine to make Pie particles. Pie particles combine to make Nom ("nominal") particles, and noms combine to make void. In the void, there are ... claws!

Jugo doesn't do Math

The number particles combine with each other in just two ways: two of the same number will combine to make the next higher particle, or two numbers that add to 15 will combine to make a pie particle. Any two pies will combine, and the two opposite color nom particles combine to make void. The claws that live in the void like the pies and noms and will try to grab them if they can. The strategy in Fourtex Jugo usually involves keeping the claws away from your pies and noms until you can beat the target score.

How do you Win?

When you complete a level . . . and have more points than Jugo, you get a star. If you reached the target score you have won the game and get two stars. If you have won without giving a particle to Jugo or having Jugo's claws grab a pie or nom, you get all three stars-- you have played a perfect game! There are levels of various difficulty, but getting three stars is usually quite challenging.

Each designed level is unique and so each level has a leader-board for competing against yourself or other players. Jugo himself also has a leaderboard. Don't think of it as just a hall of shame-- it can be a slightly different way to play the game in trying deliberately to get a high score for Jugo.

Fourtex Jugo has controller support as well as keyboard or mouse support, and has simple configuration menus for adjusting audio and other parameters.

Features:

• Play casually just to complete a level, or play to achieve a high score, or play to get a perfect game
• Levels are handcrafted by humans
• Additional daily randomized levels
• Original art and audio
• Leaderboards, achievements, stats

Fourtex Jugo is available now on Steam:

http://store.steampowered.com/app/499560/

Fourtex Jugo | Extended Play YouTube

You can statically ignore Unity unit tests by applying the [Ignore] attribute. That works fine if you only have a few work-in-progress tests to ignore. What about the use case where you have hundreds of tests that need to be ignored? This use case is very common when you have a single code framework that supports multiple games on multiple platforms.

Here at Salty Dog, we’ve tried a couple of different methods to dynamically ignore unit tests. We've tried the slow way using Assert.Ignore and a faster method using compiler defines.

The example code snippets below are from our multiple product code base used by our Fourtex products.

The Slow Approach: Assert.Ignore

This approach executes the [Setup] method for each test class before the test class is ignored. Test time really adds up when you have good test coverage.

An additional downside to this approach is that filtering by Assert.Ignore is not implemented for dynamically ignored tests. You can end up with hundreds of ignored tests in the IDE and no way to hide them.

Here's our example code.

…

using SDD.Players;  
using SDD.Campaigns;  
using SDD.Campaigns.Zen;

namespace SDD.Test.Zen {

  [TestFixture]
  [Category("Campaigns")]
  public class CampaignTest : UnitTest {

    private Campaign campaign;

    [SetUp]
    public void Before() {

      if (Settings.ProductCode != ProductCode.Zen) {
        Assert.Ignore("These tests are for 'ProductCode.Zen'");
      }

      campaign = new MainCampaign();
    }
…

The Fast Approach: Compiler Defines

Wrap the [Ignore] attribute in compiler defines. This method is filterable in the Unity IDE. Better and Faster! Wee!

…
using SDD.Players;  
using SDD.Campaigns;  
using SDD.Campaigns.Zen;

namespace SDD.Test.Zen {

  #if !SDD_PRODUCT_ZEN
  [Ignore]
  #endif

  [TestFixture]
  [Category("Campaigns")]
  public class CampaignTest : UnitTest {

    private Campaign campaign;

    [SetUp]
    public void Before() {
      campaign = new MainCampaign();
    }
…

How do you handle this? Tweet me. See below.

The Unity Test Tools don't have shortcut keys to run your test suites. All the interesting methods are private. The following code adds shortcuts for running both unit and integration tests.

NOTE: This is a followup article to article Unity Shortcuts via Reflection

using UnityEditor;  
using UnityEngine;  
using UnityTest;  
using System.Collections.Generic;  
using System.Linq;  
using System.Reflection;

namespace SDD.Editor {

  /// <summary>
  /// Salty Dog Digital Unity IDE shortcuts
  /// </summary>
  public class Shortcuts : MonoBehaviour {

    /// <summary>
    /// Auto running unit tests after each recompile getting you down?  Add a
    /// shortcut.
    /// </summary>
    [MenuItem("Unity Test Tools/Run Unit Tests %u")]
    static void RunUnitTests() {
      EditorApplication.ExecuteMenuItem("Unity Test Tools/Unit Test Runner");

      System.Type type = typeof(UnitTestView);
      FieldInfo info = type.GetField("s_Instance", BindingFlags.NonPublic | BindingFlags.Static);
      UnitTestView unitTestView = (UnitTestView) info.GetValue(null);
      // find overloaded method "RunTests()"
      MethodInfo methodInfo = unitTestView.GetType().GetMethods(BindingFlags.NonPublic | BindingFlags.Instance).FirstOrDefault(method => method.Name == "RunTests" && method.GetParameters().Count() == 0);
      methodInfo.Invoke(unitTestView, null);
    }

    [MenuItem("Unity Test Tools/Run Unit Tests (Selected) %#u")]
    static void RunUnitTestsSelected() {
      EditorApplication.ExecuteMenuItem("Unity Test Tools/Unit Test Runner");

      System.Type type = typeof(UnitTestView);
      FieldInfo info = type.GetField("s_Instance", BindingFlags.NonPublic | BindingFlags.Static);
      UnitTestView unitTestView = (UnitTestView) info.GetValue(null);

      info = type.GetField("m_TestLines", BindingFlags.NonPublic | BindingFlags.Instance);
      UnitTestRendererLine m_TestLines = (UnitTestRendererLine) info.GetValue(unitTestView);
      m_TestLines.RunSelectedTests();
    }

    [MenuItem("Unity Test Tools/Run Unit Tests (Failed) %&u")]
    static void RunUnitTestsFailed() {
      EditorApplication.ExecuteMenuItem("Unity Test Tools/Unit Test Runner");

      System.Type type = typeof(UnitTestView);
      FieldInfo info = type.GetField("s_Instance", BindingFlags.NonPublic | BindingFlags.Static);
      UnitTestView unitTestView = (UnitTestView) info.GetValue(null);

      info = type.GetField("m_TestLines", BindingFlags.NonPublic | BindingFlags.Instance);
      UnitTestRendererLine m_TestLines = (UnitTestRendererLine) info.GetValue(unitTestView);

      info = type.GetField("m_ResultList", BindingFlags.NonPublic | BindingFlags.Instance);
      List<UnitTestResult> m_ResultList = (List<UnitTestResult>) info.GetValue(unitTestView);
      Debug.Log(m_ResultList);

      m_TestLines.RunTests(m_ResultList.Where(result => result.IsFailure || result.IsError).Select(l => l.FullName).ToArray());
    }

    [MenuItem("Unity Test Tools/Run Integration Tests %t")]
    static void RunIntegrationTests() {
      EditorApplication.ExecuteMenuItem("Unity Test Tools/Integration Test Runner");

      System.Type type = typeof(IntegrationTestsRunnerWindow);
      FieldInfo info = type.GetField("s_Instance", BindingFlags.NonPublic | BindingFlags.Static);
      IntegrationTestsRunnerWindow testRunner = (IntegrationTestsRunnerWindow) info.GetValue(null);
      MethodInfo methodInfo = testRunner.GetType().GetMethods(BindingFlags.NonPublic | BindingFlags.Instance).FirstOrDefault(method => method.Name == "RunTests");
      object[] objArray = new object[1];
      objArray[0] = TestComponent.FindAllTestsOnScene().Cast<ITestComponent>().ToList();
      methodInfo.Invoke(testRunner, objArray);
    }

    [MenuItem("Unity Test Tools/Run Integration Tests (Selected) %#t")]
    static void RunIntegrationTestsSelected() {
      EditorApplication.ExecuteMenuItem("Unity Test Tools/Integration Test Runner");

      System.Type type = typeof(IntegrationTestsRunnerWindow);
      FieldInfo info = type.GetField("s_Instance", BindingFlags.NonPublic | BindingFlags.Static);
      IntegrationTestsRunnerWindow testRunner = (IntegrationTestsRunnerWindow) info.GetValue(null);
      MethodInfo methodInfo = testRunner.GetType().GetMethods(BindingFlags.NonPublic | BindingFlags.Instance).FirstOrDefault(method => method.Name == "RunTests");
      object[] objArray = new object[1];
      objArray[0] = Selection.gameObjects.Select(t => t.GetComponent(typeof(TestComponent))).Cast<ITestComponent>().ToList();
      methodInfo.Invoke(testRunner, objArray);
    }

  }
}

GitHub Gist

Auto running unit tests after each recompile getting you down? Take control, reflect a bit, and add a shortcut.

Auto running unit tests is a great idea...as long as it happens in a separate process or in the cloud. The Unity unit test runner is a private mouse only affair and it will take focus until all the tests are complete. The following editor code will add a menu item and hotkey to load and run unit tests manually.

NOTE: There is a followup to this article with additional shortcut keys More Unity Shortcut Keys

using UnityEditor;  
using UnityEngine;  
using UnityTest;  
using System.Linq;  
using System.Reflection;

namespace SDD.Editor {

  /// <summary>
  /// Salty Dog Digital Unity IDE shortcuts
  /// </summary>
  public class Shortcuts : MonoBehaviour {

    /// <summary>
    /// Auto running unit tests after each recompile getting you down?  Add a
    /// shortcut to the private method "RunTests".
    /// </summary>  
    [MenuItem("Unity Test Tools/Run Unit Tests %u")]
    static void RunUnitTests() {
      // make sure the runner is open
      EditorApplication.ExecuteMenuItem("Unity Test Tools/Unit Test Runner");

      System.Type type = typeof(UnitTestView);
      FieldInfo info = type.GetField("s_Instance", BindingFlags.NonPublic | BindingFlags.Static);
      UnitTestView unitTestView = (UnitTestView) info.GetValue(null);
      // find overloaded method "RunTests()"
      MethodInfo methodInfo = unitTestView.GetType().GetMethods(BindingFlags.NonPublic | BindingFlags.Instance).FirstOrDefault(method => method.Name == "RunTests" && method.GetParameters().Count() == 0);
      methodInfo.Invoke(unitTestView, null);
    }

  }
}

GitHub Gist

This is where someone tells me there already is a unit test hotkey.

August 26th is National Dog Day in the US

WoofSalty says

Take your dog to the beach!

Late 9th or early 10th century. Prince Motoyoshi was son of Yōzei (poem no. 13). The Prince has been caught having a forbidden intimate relationship, and this poem expresses his despair of the situation. Bay of Naniwa means Bay of the Swift Waves.

Resolve In Despair

Now, in dire distress,  
  It is all the same to me!
So, then, let us meet  
  Even though it costs my life
  In the Bay of Naniwa.

Prince Motoyoshi

Wabinureba  
  Ima hata onaji
Naniwa naru  
  Mi wo tsukushite mo
  Awanu to zo omou.

Motoyoshi Shinnō  

9th century. The writer, the Lady of Ise, was the daughter of the governor of Ise, on Honshu, and the mother of a Prince, and a scholar in her own right.

A Lover’s Reproach

Even for a space,  
  Short as joint of tiny reed  
From Naniwa’s marsh,  
  We must never meet again  
  In this life? This, do you ask?

Lady of Ise

Naniwagata  
  Mijikaki ashi no  
Fushi no ma mo  
  Awade kono yo wo  
  Sugushite yo to ya.

Ise