232 lines
9.4 KiB
Java
232 lines
9.4 KiB
Java
/*
|
|
*
|
|
* Note.java
|
|
*
|
|
* Class defines what will be in a configuration file for a user note. All metadata is in this class when read from file
|
|
*/
|
|
|
|
package jesse.keeblarcraft.JsonClassObjects;
|
|
|
|
import java.util.HashMap;
|
|
import java.util.Map.Entry;
|
|
|
|
import jesse.keeblarcraft.ConfigMgr.ConfigManager;
|
|
import jesse.keeblarcraft.Keeblarcraft;
|
|
import jesse.keeblarcraft.ChatStuff.ChatMsg;
|
|
|
|
public class PlayerNote {
|
|
/// Class variables
|
|
NoteFile thisNote = new NoteFile();
|
|
ConfigManager config = new ConfigManager();
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
/// @class NoteMetadata
|
|
///
|
|
/// @brief The metadata that is attached to each entry in the notebook.
|
|
/// This includes not just the note itself, but other important
|
|
/// factors that can be characteristic to each note and useful
|
|
///
|
|
/// @note You can picture this as each page in the notebook if it's
|
|
/// an easier mental image
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
private class NoteMetadata {
|
|
public NoteMetadata(String note, long id, /*long mcday,*/ long sysTime, long chapter, long part) {
|
|
this.note = note;
|
|
this.noteId = id;
|
|
// this.minecraftDay = mcday;
|
|
this.systemTime = sysTime;
|
|
this.storyChapter = chapter;
|
|
this.storyPart = part;
|
|
}
|
|
|
|
String note; // The note itself
|
|
|
|
long noteId; // Copied in from the file name, noteId
|
|
// long minecraftDay; // The minecraft day the note was taken on
|
|
long systemTime; // The current system time of the server
|
|
long storyChapter; // The chapter of the story the player is in
|
|
long storyPart; // Every event in a story is one part
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
/// @class NoteFile
|
|
///
|
|
/// @brief This is the notebook
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
public class NoteFile {
|
|
// the uuid is the name of the file written to disk
|
|
String uuid;
|
|
public HashMap<Integer, NoteMetadata> noteMap = new HashMap<Integer, NoteMetadata>();
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
/// @fn PlayerNote
|
|
///
|
|
/// @brief This class's non-trivial constructor. Grabs a handle on the
|
|
/// server-side file that is the players notebook at object
|
|
/// creation. If one does not exist, one is created
|
|
///
|
|
/// @arg[in] uuid is the players uuid value
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
public PlayerNote(String uuid) {
|
|
|
|
// DEVELOPER NOTE:
|
|
// If you are testing this part of the code, please be reminded that anonymous testing starts a new
|
|
// player instance everytime you launch. This means the UUID CAN CHANGE when you launch the
|
|
// game! This is not an issue with proper registered accounts in production
|
|
Boolean existingFile = false;
|
|
try {
|
|
thisNote = config.GetJsonObjectFromFile("notes/" + uuid + ".json", NoteFile.class);
|
|
existingFile = true;
|
|
} catch (Exception e) {
|
|
// Do nothing. This means the file does not exist
|
|
}
|
|
|
|
// In the event the above code failed out, this means a new file has to be created for the player's uuid
|
|
if (!existingFile)
|
|
{
|
|
try {
|
|
thisNote.uuid = uuid;
|
|
FlashConfig();
|
|
} catch (Exception e) {
|
|
Keeblarcraft.LOGGER.warn("Could not write to the player notes file");
|
|
}
|
|
}
|
|
|
|
// It's possible the above code will return a blank class if a file doesn't exist. This will make
|
|
// a new file with this players uuid
|
|
if ("".equals(thisNote.uuid)) {
|
|
System.out.println("Assigning new config file for this uuid. No previous existing");
|
|
thisNote.uuid = uuid;
|
|
}
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
/// @fn AddNote
|
|
///
|
|
/// @brief Adds a new note to the notebook
|
|
///
|
|
/// @arg[in] newNote is the new string value of the note
|
|
///
|
|
/// @arg[in] minecraftDay is currently unsupported but will be the day of
|
|
/// the minecraft world when it is implemented
|
|
///
|
|
/// @arg[in] systemTime is the epoch time in milliseconds
|
|
///
|
|
/// @arg[in] storyChapter is the chapter in the story this note was taken
|
|
///
|
|
/// @arg[in] storyPart is the part in the chapter the note was taken
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
public void AddNote(String newNote, long minecraftDay, long systemTime, long storyChapter, long storyPart) {
|
|
Integer noteKey = thisNote.noteMap.size() + 1;
|
|
thisNote.noteMap.put(noteKey, new NoteMetadata(newNote, noteKey, /*minecraftDay,*/ systemTime, storyChapter, storyPart));
|
|
|
|
FlashConfig(); ///TODO: This might be really unnecessary and may only be required on clean up as opposed to everytime the command is run
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
/// @fn DeleteNote
|
|
///
|
|
/// @brief Deletes a note in the notebook
|
|
///
|
|
/// @arg[in] noteId is the id to delete
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
public void DeleteNote(Integer noteId) {
|
|
thisNote.noteMap.remove(noteId);
|
|
FlashConfig();
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
/// @fn ModifyNote
|
|
///
|
|
/// @brief Modifies a note at noteId entry OR creates new note at that
|
|
/// entry if the id didn't exist previously
|
|
///
|
|
/// @arg[in] noteId is the id we wish to modify the note of
|
|
///
|
|
/// @arg[in] newNote is the new string value of the note
|
|
///
|
|
/// @arg[in] minecraftDay is currently unsupported but will be the day of
|
|
/// the minecraft world when it is implemented
|
|
///
|
|
/// @arg[in] systemTime is the epoch time in milliseconds
|
|
///
|
|
/// @arg[in] storyChapter is the chapter in the story this note was taken
|
|
///
|
|
/// @arg[in] storyPart is the part in the chapter the note was taken
|
|
///
|
|
/// @return 0 if success, -1 if not
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
public void ModifyNote(Integer noteId, String newNote, /*long minecraftDay,*/ long systemTime, long storyChapter, long storyPart) {
|
|
thisNote.noteMap.put(noteId, new NoteMetadata(newNote, noteId, /*minecraftDay,*/ systemTime, storyChapter, storyPart));
|
|
FlashConfig();
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
/// @fn PurgeAllNotes
|
|
///
|
|
/// @brief Wipes the players notebook clean
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
public void PurgeAllNotes() {
|
|
thisNote.noteMap.clear();
|
|
FlashConfig();
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
/// @fn GetNoteString
|
|
///
|
|
/// @brief Gets the note string in the map by identifier. NOT metadata
|
|
///
|
|
/// @arg[in] key is the map key we wish to return
|
|
///
|
|
/// @return Empty string if that ID contains no note, or string with note
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
public String GetNoteString(Integer key) {
|
|
if (thisNote.noteMap.containsKey(key)) {
|
|
return thisNote.noteMap.get(key).note;
|
|
} else {
|
|
return "";
|
|
}
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
/// @fn GetNotebookSize
|
|
///
|
|
/// @brief Returns the size of the notebook object
|
|
///
|
|
/// @return Size of notebook
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
public Integer GetNotebookSize() {
|
|
return thisNote.noteMap.size();
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
/// @fn GetNoteKey
|
|
///
|
|
/// @brief Returns the key identifier of a note by the value in the map
|
|
///
|
|
/// @arg[in] currentNote is the string note that we wish to see if exists
|
|
///
|
|
/// @return 0 or positive number if key found, negative number if not
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
public Integer GetNoteKey(String currentNote) {
|
|
Integer ret = -1;
|
|
for (Entry<Integer, NoteMetadata> entry : thisNote.noteMap.entrySet()) {
|
|
if (entry.getValue().note.equals(currentNote)) {
|
|
ret = entry.getKey();
|
|
}
|
|
}
|
|
FlashConfig();
|
|
return ret;
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
/// @fn FlashConfig
|
|
///
|
|
/// @brief Writes to the configuration file
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
public void FlashConfig() {
|
|
config.WriteToJsonFile("notes/" + thisNote.uuid + ".json", thisNote);
|
|
}
|
|
}
|