GMC Jam Player Overhaul

Alice

Toolmaker of Bucuresti
Forum Staff
Moderator
This is a thread dedicated to coordinating the overhaul of GMC Jam Player. This includes:
  • Making development decisions regarding the player (possibly other tools, too)
  • Gathering people who could help develop the Jam Player
  • Gathering planned features list and giving them concrete shape (designing the UX, underlying structures etc.)
  • Posting builds for testing and playing around with

I suppose if things go well, it may be easily expanded into a general-purpose Jam Player (not only for GMC Jams specifically) so that it can be used for other game jams, too.
Expanding into a general-purpose Jam Player has the added advantage of attracting more potential contributors.

Technology
In other words, which framework/engine/codebase should be used for Jam Player application (and potential other applications).
Right now, I would consider one of these three, on the ground that I'm completely unfamiliar with anything else:
  • .NET + C#
    Within .NET, I'd use Windows Presentation Foundation frontend. An alternative within .NET codebase would be UWP, but it's not supported on Windows before 10.
    + I am very familiar with it, so I can setup the foundation
    ++ In fact, I might have some foundation already from my earlier work on Jam Entry Packager
    + It has conventional controls out of the box (textboxes, dropdowns and such)
    + Tried and tested on previous Jam Player (but I don't have the old player codebase)
    ? There might or might not be many people willing and able to help using .NET + C#
  • Electron
    I think it's somewhat popular recently? It's this sort of browser-in-a-desktop-app technology, based on HTML/CSS/JS if I'm not mistaken.
    + It has conventional controls out of the box
    + More cross-platform, I think (though it's more of an advantage for general-purpose Jam Player, rather than GMC Jam Player specifically)
    ? Based on HTML/CSS/JS which should be well-known, but I don't know how well-liked (again, how easy would it be to find contributors)
    ? Has additional design decision related to which set of frameworks/libraries to use, if at all (for example Angular)
    - Not familiar with it, so I wouldn't be able to easily setup the foundation
  • GameMaker
    I think I don't need to explain this one.
    + Many people here are familiar with it, so it's easier to find someone who can contribute
    ? There would be some work involved with exploring, loading and running the files, maybe?
    - Has no conventional controls out of the box, we'd either need to code them ourselves or find good and free Marketplace assets
So far it seems like .NET + C# + WPF would be the best choice, but it's because it's my preferred UI codebase, so of course it's easier for me to point out its advantages. The biggest potential problem is having not enough contributors (though there's already one person willing to help there).
If someone has remarks about other technologies they're familiar with (whether the ones listed or not mentioned here), feel free to share.

Whichever technology we choose, I assume there'd be a public GitHub repository with all the codebase. That'd make it easier for people to contribute as well.

Functionality
The list of functionality of Jam Player and possibly other related apps.

To be included...
 

Alice

Toolmaker of Bucuresti
Forum Staff
Moderator
Reposting @Micah_DS original suggestions, so that his post doesn't appear above my opening post (because of timestamps):
--------------------

I was going to post in the jam discussion, but realized this topic exists exactly for this purpose, so here goes. :)
I noticed the talk of a new/reworked jam player, and I'm probably not going to be useful in helping with code, so instead I wanted to speak as a user, giving my feedback on features - what I like about the current jam player, desired improvements, etc.

So, in the interest of improving the jam player, here are my thoughts and wishes regarding the features:

ADD​
  • Ability for the user to add new (missing) entries to the jam player.
    This would allow the addition of valid entries that for some reason didn't make it into the jam player on the first go.
    With this, we wouldn't have to manually edit the exported data to add in other games to our votes and reviews. Based on what I've seen in the recent and past jams, I believe missing games is a common enough occurrence to warrant this feature.

    Games added in by the user wouldn't need to be able to get directory paths from the program to the exe or readme, though if that could be managed, it'd be a bonus. The main goal is to be able to vote/rank and comment on them, and for it to be included in the export, just like the other entries.

  • Game thumbnails (I'm aware this is already being considered, but I'm basically just saying that I really, really want it), or perhaps functionality for the user to paste their own 'print screen' clipboard data directly into a slot inside the player (one slot per game), so the user could choose their own image to represent the game.
    Maybe that's a pipe dream though. Oh! It'd be even more awesome to be able to have multiple screenshot slots for each game. Ah, an even more unreasonable request! :p
    Either way, be it thumbnails or custom screenshots, the idea is to be able to get a visual for the user to remember the game more quickly and vividly, helping them vote and comment even more accurately and with more ease.

  • Customizable export format - MY MOST WANTED FEATURE
    This might be asking too much, but it'd be sooooo nice to be able to change some things in the format to save myself some post-editing time.
    For e.g., I always encase each game's comment inside a spoiler. If I could add this into the export format itself, it'd save me so much time and hassle. Up till now, I've been adding the spoiler tags into each game's comment section before export, and sometimes I forget to add it in a comment or I mess up and it ends up costing me a fair amount of time.

    Additionally, if I could save the format as a text file, then simply load that file in to the jam player in future jams, I'd always be ready to go after one simple action, as opposed to having to edit the format again. That'd be positively magnificent.

    That said, this feature would require a fair level of flexibility if it were to allow me to make a format that achieves the results I always go for, and other people might want more complex formats as well.
    For e.g., I always use certain colors for game titles and other parts of the text, and I use the @ mention for each individual person in the best ofs and top three games.
    In the end, even if it can't save me entirely from doing post-edits, I'm sure it'd still save me a bunch of time, and I'd appreciate it so much.
REWORK​
  • In the "Choose best-ofs" section: Allow drag and drop from the ranking list to best-of slot, instead of (or, as well as) the drop-down lists.
    Maybe it's just me, but I feel like this would give a much better UX, making it even easier and faster.

  • The "Rate" section of a game's page needs a total makeover, as many have already proposed.
    I almost never use the Rate section, and I know I'm not the only one.

    So, there appears to be two main goals to accommodate:
    1. The ranking system is for the user, being usable to auto-rank entries based on scores.
    2. The ranking system is for feedback purposes, able to be added to comments in the export.

    For goal 1, there could be a button "Sort rank by score". Clicking it would sort from the highest overall score to lowest. For ties, it could sort alphabetically. From there, the user could manually edit the order, as usual.
    For this feature, you wouldn't want it to only sort scored games in the ranked section, because users will likely put in their scores while a game is in the unranked section, expecting the sort button to add that and any other unranked-yet-scored games to the ranked section automatically, while also sorting them, of course. Seeing this, we'd also want to clear the score of a ranked game whenever it's moved back to the unranked section., to avoid it being added back into the ranked accidentally and/or to prevent the user from having to clear the score manually. Admittedly, there may be rare cases where someone wants to keep the score, even when left unranked, so perhaps there's a better way to go about this.

    For goal 2, in the export, the goal would be to have it show up in a game's comment like this, for example:

    Enjoyment: 30 / 40
    Theme Use: 15 / 20
    Game Feel: 15 / 20
    Graphics: 10 / 10
    Audio: 10 / 10

    Overall: 80 / 100


    In summary, a new rating system like this would need the following:
    • Converting the "Poor, OK, Good, Great" system to a "num / num" system. Possibly maintaining "N/A" as an option, since some people might want "0" to be an actual rating (maybe?).
    • Option to add/remove any category, and - when adding a category - being able to type in a custom name for it (up to a certain length, of course).
    • Each category would get its own customizable max number range, because I know that some people like to have a 100 point total where some categories account for more points than others (as seen in my example above).
    • An option for the export to add or exclude the ratings in the comments.
    • If the ratings are included with comments, there should be some choices: Whether to place ratings before or after comments, and whether to include the summed up overall score or not.
    • A "Sort rank by score" button, probably placed near the "Ranking" list.
    • Etc. ("Etc." because I'm certain I'm not thinking of everything)

    NOTE:
    If the customizable export format became a thing, some of these things could be handled in the format editing, like whether to include ratings with comments or not. That'd be optimal.
KEEP​
  • Drag and drop from unranked to ranked entries, placing exactly where you drop in the ranked list, as opposed to always adding to the bottom, regardless of where you drop it in the ranked list.
    I'm saying this because I remember it used to add to the bottom all the time (Right? I doubt I dreamt that), and this is SO much nicer. I don't know when it was updated, but I love it.

  • General layout.
    Even if some things are added or removed, the general layout of things seems good. Game lists on left, comment section lower right, etc.

So, uh.. that's all that comes to mind for now. ;)
(Shoot.. I wrote way more than I thought I would)
 

Toque

Member
If games and reviews were sorted alphabetically that would be nice.

I started using screen shots. It makes it easier to remember the games and sort ranking.

 

dadio

Potato Overlord
Forum Staff
Moderator
I'd say don't go too wild. It takes time to implement this stuff, so focus on the "must haves".
Personally, the single biggest change that I think everyone benefits from is the "screenshot" thing...
but it would mean that ideally someone (the jam runner or yourself) would have to play each game a for a minute before uploading the Jam zip, to take a representative game-play screenshot and add it to each game...
(as well intentioned as letting people do their own screens sounds, I reckon in practice, most would not bother) - really someone has to do that manually for every Jam.
So, yeah, there's effort there for someone, on top of the usual Jam duties.
But I really think it would be a huge benefit to reviewers (and just plain nice!)

After that, I'd say allowing different sorting methods, alphabetical by game name / alphabetical by creator name/ by ranking / etc. would also be very helpful.
Especially alphabetical.

All features beyond that I'm not too fussed on.
Just my 2 cents.

Also, massive props for going above and beyond with the Jam Player.
Your work for this community is always appreciated!


PS: Man, I really gotta get round to sorting out that Jam Archive topic...
 

Cameron

Member
@dadio I could be wrong but I think the screenshot request is mainly by users who just want the ability to do their own screen captures and then add them to the game through the jam player. So each game would have an image scroll that could start off empty and you could add to it via an "add screenshot" button or maybe even some drag and drop functionality of the image from another folder, just dragging it on the image scroll for that game. But I'm not too sure, I'm making some assumptions here, I'll have to go back and read the screenshot requests.

In addition though, another option with the screenshots is we could pre-load some image scroll screenshots if the "Jammers" submitted them in the folder. The process could be automated if we request they submit screenshots with a certain pre-fix or post-fix, much like how the GMS IDE knows to break an image into sub-images when you post-fix an image with "strip" and the number of images. The jam player, on initialization, could do a finite recursive directory dive of the chosen jam folder and not only use that to search for executable's but also for any images designated for the games image scroller.

Both methods would probably be welcome additions that would require no extra work for the person distributing the player.
 

Alice

Toolmaker of Bucuresti
Forum Staff
Moderator
For the record, the thumbnails feature was on a radar for a while, and even taken into account in the prototype Jam Entry Packager.

Basically, the jammer would pick a thumbnail (not necessarily a whole screenshot, but a preferably square-shaped part of it) to include with their game, and that thumbnail would be displayed alongside the entry information - in big size within the entry view (near the game info + run/readme buttons) and in small size in the list view. Hopefully that would be enough to keep the entries clearly distinguishable and memorable. As long as enough people include their preferred thumbnails, there should be no problem for the jam host to add the rest of thumbnails.

I don't think the reviewers' screenshots are a priority at the moment. This one is more challenging from UX perspective and comes with several design decisions - do we allow posting screenshots from clipboard? Do we add simple cropping tools? Would there be a hotkey to add the screenshot to gallery automatically? Or maybe we just go the simples route and allow picking the screenshots from disk (but it has significantly larger UX overhead)?
So yeah, I think reviewers' screenshots - while not a bad idea and worth adding sometime in the future - have lower usefulness-to-effort ratio than other features (especially to relatively low-effort thumbnails).
 

dadio

Potato Overlord
Forum Staff
Moderator
"Basically, the jammer would pick a thumbnail (not necessarily a whole screenshot, but a preferably square-shaped part of it) to include with their game, and that thumbnail would be displayed alongside the entry information - in big size within the entry view (near the game info + run/readme buttons) and in small size in the list view. Hopefully that would be enough to keep the entries clearly distinguishable and memorable. As long as enough people include their preferred thumbnails, there should be no problem for the jam host to add the rest of thumbnails. "

Hmmm... yeah, allowing people to do their own screens through the player seems like way too much work (for you) and is assuming most people would bother using/doing that (I don't think most would.)
Having people submit 2 screens along with their entries - in theory that would work... but I'd be interested to see how that would turn out in the end.
Alotta peeps seem to wait til near the very end to submit... I imagine adding 2 screenshots (1 square) would be low on their list of priorities when scrambling to submit...
Still, would love to see it.
If ready for the next Jam, the Jam host needs to make that extra new info about screenshots POP on the Jam rules/requirements section.
 

Toque

Member
Actually most people include a image of some sort in the submission post. I pulled the majority of images from there. There was only a few I needed by playing them.
 
So far it seems like .NET + C# + WPF would be the best choice, but it's because it's my preferred UI codebase, so of course it's easier for me to point out its advantages. The biggest potential problem is having not enough contributors (though there's already one person willing to help there).
I would be willing to help, however I am not familiar with this specific tech stack (I went more on the Java based branch of it :p), but it should be fairly simple to pick up. So if you need an extra pair of hands you can count me in.

In terms of suggestions, I think the Jam Player currently only works with the Windows executable versions, right? Could be cool to allow other platforms like Linux or at least HTML5 to be launched as well, for the entries that support it (although I know the rules state that a Windows submission is mandatory iirc)
 
Not sure how feasible this is(Especially since it would probably depend on the UI layout), but what I'd really like to see is readme.txt files embedded somehow. For instance, you click on a game and it brings up the game info(Name and authors), with the rating system buttons or whatever, and the textbox where we leave our comments. But if a readme.txt is available, it is automatically displayed somewhere on there too.
It would just be a bit nice to instantly see potential controls and other info without needing to open a text file.
 

FrostyCat

Member
I have developed a temporary tool that adds the templating and score ranking features to the format used by the existing Jam Player. While I won't be available to help out with the actual redevelopment, this should be full-featured enough to satisfy most review-posting needs until the relaunch is ready.
 

Micah_DS

Member
After more thought, I'd say thumbnails would suffice. If anyone wants to do a screenshot thing, they can use another method to store, arrange, etc., without much extra trouble. For e.g., next jam, I'm planning to paste screens in a OneNote doc to display and arrange them.

THUMBNAIL SAVER TOOL/SCRIPT:

OK, so this is admittedly a smaller thing, but I think it could be beneficial for some jammers. I know it's going to help me, personally (when/if thumbnails are implemented).
I've made a small GML script that captures thumbnails. Here's my attempt at quickly showing how it works:
(Note: When the selection appears to be jerking around, that was me snapping it to the grid, btw, not lag, though the gif isn't perfectly smooth either)

The script has three arguments: Thumbnail size, grid snap size, and OS username (for getting the exact thumbnail filepath.. hopefully). Arguments are set up as optional with defaults, to allow for faster/easier use. Whether a camera/view is used or not is also accounted for in the code. It's still a bit too restricted though, not being usable on the GUI layer or on a scaled game, and it must be called within the Draw End event, at a point where everything you want to be captured is already drawn.

HERE IS THE SCRIPT:
GML:
/// @desc capture/save a square thumbnail .: place in Draw or Draw End event, after everything you want to be captured has been drawn
/// @arg thumb_size  .: represents both x and y number of pixels, as thumbnails are always 1:1 ratio
/// @arg snap_size   .: make this the size of your tiles for the snap feature to align and snap to the tile grid
/// @arg os_username .: your Windows username that's used in your filepath for your local appdata

// ! IMPORTANT !
//
// 1) this will not work in a GUI draw event
// this means anything in the GUI event won't be captured
// on top of that, since the thumbnail previewer is drawn before the GUI, GUI elements will draw over this
//
// 2) this will not work if your game is scaled up/down from its base resolution (e.g. scaled to fullscreen)
// sorry, i could probably make a workaround via surface usage, perhaps, but i haven't looked into it

//
var thumb_size      = (argument_count <= 0? 128   : argument[0]); // make argument optional with defaults
var snap_size       = (argument_count <= 1? 16    : argument[1]); // ^
var os_username     = (argument_count <= 2? "John": argument[2]); // ^
var thumb_size_half = floor(thumb_size/2);
var snap_size_half  = floor(snap_size /2);
var is_snapped      = mouse_check_button(mb_right);

// set top-left origin, accounting for a view and camera, or a lack thereof
var room_x = (!view_enabled? 0: camera_get_view_x(camera_get_active()));
var room_y = (!view_enabled? 0: camera_get_view_y(camera_get_active()));

// set centered thumbnail position modifiers, based on mouse position
var mcx = mouse_x-thumb_size_half;
var mcy = mouse_y-thumb_size_half;
mcx     = (is_snapped? (floor((mcx + snap_size_half) / snap_size) * snap_size): mcx);
mcy     = (is_snapped? (floor((mcy + snap_size_half) / snap_size) * snap_size): mcy);

// tool is only active while holding this button .: because it seemed the best way to handle it, all things considered
if keyboard_check(vk_lshift)
{
    var filepath   = "C:\\Users\\"+os_username+"\\AppData\\Local\\"+game_project_name;
    var text_upper = "Press LMB: Save -- Hold RMB: Grid snap";
    var text_lower = "Press MMB to copy:\n"+filepath;

    if mouse_check_button(mb_left)   {text_upper = "Thumbnail saved!"};               // to add some "better than nothing"(?) user feedback
    if mouse_check_button(mb_middle) {text_lower = "Filepath copied to clipboard!"};  // ^

    // draw everything
    draw_set_halign(fa_center);
    draw_text(mcx+thumb_size_half, mcy-24, text_upper);
    draw_text(mcx+thumb_size_half, mcy+thumb_size, text_lower);
    draw_set_halign(fa_left);

    draw_rectangle_color(mcx, mcy, mcx+thumb_size-1, mcy+thumb_size-1, c_yellow, c_red, c_teal, c_lime, true);

    // save thumbnail
    if mouse_check_button_pressed(mb_left) {screen_save_part("Thumbnail.png", mcx-room_x, mcy-room_y, thumb_size, thumb_size)};

    // copy thumbnail's filepath (unless your OS isn't installed on C:\ and/or your os_username doesn't match up)
    if mouse_check_button_pressed(mb_middle) {clipboard_set_text(filepath)};
}

I don't know how many people this would actually help though. It depends on habits and personal workflow. All I know is, for me, it'll help ensure I can submit a good thumbnail and include it with my game submission, even if I'm scrambling like mad crunching at the end. So I'm sharing in case it'd help others do the same. Also, if anyone has any pointers on improving it, I'm open. :)
 
Last edited:

FrostyCat

Member
I would like to suggest adding a way for automated scripts to scan and enter ranking information from review posts. This is inspired by this reply on the Discussion Topic:
And now all that's left is to tally the votes and present the results. With these many entries, it's gonna take a while... ^^'
An example of such a format would look something like this, with the voter's name, numeric entry IDs in order of ranking, and numeric entry IDs for best-ofs in each category:
Code:
[gmcjam]FrostyCat;3,1,5,6,2,4;4,2,6,-[/gmcjam]
Then the voting page's source code can simply be scanned by a script and processed automatically.
 
I wanted to toss out my suggestion for an Electron based application. I've been in web dev for about 15 years so I might be biased a bit, but a JS based application that allows for cross platform, plus you get built in web based APIs/SDKs that will allow you to interact well with things like the Forum, HTTP requests, Fetching Games from sources like Itch (butler comes to mind). Electron's OS level API also allows cool things like Jumplists in the windows taskbar, and other cool features.

That said, I had some free time and threw together a quick project using Electron, Vuejs, and Tailwindcss to mock up a player that showed off how easy some of the items on the checklist are to accomplish in some simple Javascript. Feel to download the repo and run it and give me your thoughts. Its Here on my Github, I used the current jam player as reference and you can simply copy over the Entries folder from the current Jam player into the public folder of this project and it will scan the directories for folders and binaries/readmes and build out an Entries list.


This example includes:
  • Entries loaded from the public/Entries folder
  • Automatic Folder parsing/detection for Entries (based on GMC Jam Player's current folder approach)
  • .exe and README file scans within each Entry folder
  • Reloading application rescans directories for changes and rebuilds the Entries list
  • Sorts and Filters (Played, Unplayed, Ranked, Unranked, Name Sort, Rank Sort, Name Search Query)
  • Drag and Drop Best ofs
  • Simple Up/Down Vote Ranking
  • Entry Details Panel with Name/Authors/Screenshot(Mock)/Readme/Game Launch Button
  • Entry played tracking
This is obviously just a rough example of what you can do with Electron/Javascript, but with some more time/contributors you could add pretty much all of the features in this discussion. Obviously count me in if this is a direction you guys end up going.
 

Alice

Toolmaker of Bucuresti
Forum Staff
Moderator
I would like to suggest adding a way for automated scripts to scan and enter ranking information from review posts. [...]
An example of such a format would look something like this, with the voter's name, numeric entry IDs in order of ranking, and numeric entry IDs for best-ofs in each category:
Code:
[gmcjam]FrostyCat;3,1,5,6,2,4;4,2,6,-[/gmcjam]
Then the voting page's source code can simply be scanned by a script and processed automatically.
Someone suggested attaching the file with specifically formatted vote, but the principle is roughly the same. And I think there's no need to include extra metadata, since the votes themselves can be scraped easily enough.

The common-sense assumption is that the voter will provide the ranking as game titles and/or author names (usually both). These titles and author names should be enough to uniquely identify an entry - otherwise there's no way we can make sense of the vote in the first place. Sometimes the voter will provide some an alternative title/author name (or just make a typo), but these can be handled individually.
Similarly, we can expect that "Best of" votes are formatted like: Best something something: Title by Author(s)

So, the vote-post-scraper might look for the following:
  • the only ordered list in the post, with entries like like "[title] [authors]" (e.g. "Shibboleth by FrostyCat") or like "[authors] [title]" (e.g. "FrostyCat - Shibboleth")
  • the sequence of lines like "[number] [title] [authors]" or "[number] [authors] [title]" (e.g. "8. FrostyCat - Shibboleth")
  • the lines like "Best use of theme: [title] [authors]" or "Best use of theme: [authors] [title]" (e.g. "Best use of theme: FrostyCat - Shibboleth")

The basic requirement is that vote-post-scraper can deal with posts generated by default Jam Player template. However, most additional formats should be properly handled by the aforementioned algorithm. All that remains is to handle some irregularities (e.g. typos in titles written by hand) and do some basic human-checking, to make sure the votes roughly align with the contents of the post.

I wanted to toss out my suggestion for an Electron based application.
I really appreciate putting together the working base of GMC Jam Player - a working example is definitely more convincing than a simple declarations.

A few things to point out:
  • I would rather keep best-ofs as a separate tab or such (maybe with an option to mark an entry as a best-of from within the entry page)
  • the window acts funny when not in fullscreen - the entries bar will merge with best-ofs area
  • I couldn't get the entries auto-detection to work, not sure why; also, judging by "Entries loaded from the public/Entries folder" it sounds like Entries are meant to be packaged before the Jam Player build, i.e. the Jam Player must be rebuilt every time Entries change...?
  • also, some stylistic/UX choices, like e.g. allowing a dropdown aside from drag-and-drop on best-ofs; or having the entries ranking with one entry per line (I feel it's much more intuitive when it comes to ordered lists)

Right now, I'm not sure whether go .NET/WPF route or Electron + Vue + Tailwind + JS route (personally, I have zero experience with Vue and Tailwind).

So far it seems there are more collaborators willing to go .NET/WPF route, though. So unless some other people come in wanting to go Electron route (or even more people will want to go WPF route), I'm still inclined to implement Jam Player in WPF.
 
I really appreciate putting together the working base of GMC Jam Player - a working example is definitely more convincing than a simple declarations.
Sure thing, after reading a few posts on the topic I saw Electron tossed out as an option and figured I would prove the idea and see how doable it was.

A few things to point out:
  • I would rather keep best-ofs as a separate tab or such (maybe with an option to mark an entry as a best-of from within the entry page)
  • the window acts funny when not in fullscreen - the entries bar will merge with best-ofs area
  • I couldn't get the entries auto-detection to work, not sure why; also, judging by "Entries loaded from the public/Entries folder" it sounds like Entries are meant to be packaged before the Jam Player build, i.e. the Jam Player must be rebuilt every time Entries change...?
  • also, some stylistic/UX choices, like e.g. allowing a dropdown aside from drag-and-drop on best-ofs; or having the entries ranking with one entry per line (I feel it's much more intuitive when it comes to ordered lists)
Most of the points are very much UI/UX based, and this example was quickly slapped together, but with a bit of work would be doable to whatever direction we would want to go. Tables/Vs Card layout for entries, Drop downs vs Drag/Drop or both, tab based views/ pop up views. I'm a big fan of reusable component design, and Vue+Tailwind helps in doing that in a front end perspective. The same idea is true with the responsive nature of the window as well, all of those details can be refined based on the window size. As far as the Entries not working, for testing the sample application you just need to create the Entries folder and populate it like the GMC Jam player currently is structured (with a Folder per Game Entry inside the Entries folder). I think in a full Jam Player application the Entries folder wouldn't be populated manually or via a compilation process, you could provide an API/manifest of some kind that would allow users to download all the games either from a source, or some other means. That's the exciting nature of using JS to handle the work. You could distribute the JAM player as both a Player, as well as an Uploader/Entry platform. Moving the process of retrieving the Entries outside of the Jam Player distribution would allow bug fixes and post Jam deadline Entries as well. I'm happy to help chat more about structure/feature scoping as well.

Right now, I'm not sure whether go .NET/WPF route or Electron + Vue + Tailwind + JS route (personally, I have zero experience with Vue and Tailwind).

So far it seems there are more collaborators willing to go .NET/WPF route, though. So unless some other people come in wanting to go Electron route (or even more people will want to go WPF route), I'm still inclined to implement Jam Player in WPF.
Yea it makes sense to go down the path of the most contributors and what people are most comfortable with. If I had more experience in the .NET/WPF route i'd be happy to contribute, but not sure I'd be of much assistance.
 

Cameron

Member
I know I had once offered my services to help out with the Jam Player in WPF but I've been pretty busy and it's not looking like I'm going to be able to help out. So I'd like to officially withdraw my offer and maybe that'll help simplify the decision making process.

Looking forward to seeing the final result from whoever inherits the task.
 
Top