I'm working on a nick plugin for my network. I managed to change the name of the player. Really... It changes everywhere on the spigot server. Eaven other plugins don't get the real name.
But now I stuck in changing the skin of the player and I have one main question... Who sets the skin? Bungeecord or Spigot. In fact that the Bungeecord server is an online server and all the gameservers are offline servers I think that maybe the bungeecord-server is able to change the skin of the player. And in that case... Does anyone have a working method? Because I tryed nearly everything I've found in google.
Thanks alot.
Minecraft 1.8 and higher
The skin comes from the Mojang servers, this skin is fetched by Bungeecord at the moment of when the player logins, and is then passed over the connection to Spigot.
Spigot is then responsible for the sending this players skin to the other players on the servers in the form of a GameProfile object. If we check what this GameProfile object contains, we will see that it contains a signature and a skin data, the signature is generated by Mojang at the moment of skin change ad is based on the skin, and the skin data contains the textures used for the skin and cape. If you want to change the skin, you should register a new Minecraft account with the skin you use (or hopefully find a existing account with the skin), and use his skin data and signatures.
Minecraft 1.7 and lower
In these minecraft versions, the skin is resolved using the player's name. A request is made to http://minecraft.net/skin/<username>.png. This will return a simple png file with the skin contents. If you try this method with people who changed their name in 1.8, it will fail, since this service doesn't recognise the 1.8 usernames.
Related
We are working on an app for Hololens2. In this app multiple users can join a room and can perform different hand movements. Here challenge is, we also need to show hands of the users along with their names.
Need your help in understanding resolution for this issue.
You need to use Photon's methods to instantiate the hand prefab and then use it as a copy for live sharing. You can find hand prefabs in Mixed Reality Toolkit Foundation->SDK->Features->UX->Prefabs->RiggedHandVisualizer. Then you need to map the current hand position, rotation to this copy. You can also try to map the hand joints, please refer to Hand tracking - MRTK 2 | Microsoft Learn to get joint data.
For the name, you can ask the user to enter a display name for Photon to use before he joins the room. Then you can create a UI for it and have it display with the hand.
For school we are creating a roulette webapplication in Clojure with the webnoir framework. Everything seems realizable in Clojure, but the problem is: how do we define the board in our domain in Clojure? It must be possible to place corner bets etc.
And if we modelled this in our domain how do we send the information of the view to our domain/board?
Does anyone has ideas or suggestions?
Since there are infinite ways to define a board, many of them good, I'll avoid that question and primarily address the second: communicating between your board view and model.
One solution using webnoir is to have your board view contain form[s] to perform actions. Submitting that form updates your board model and redirects to the same route, resulting in an updated view. I'm sure you've been leafing through Chris Granger's excellent documentation.
Another route, albeit one that might be outside the scope of your project, is to have client side code dynamically communicate with the model and update your view, the end result being a single page webapp. This could be done with ClojureScript. If you are considering this, take a look at Chris Granger's libraries formerly known as pinot. They provide a wonderful complement to webnoir.
I want to make an interface that looks like this
So here is what the user can do
1- Connect people to each other
2- See some information about each person (the balloon)
3- Move these objects around without them loosing their connections
Then I want to save these connection information using ajax, so that I can see who is connected to who, I also need to redraw these diagrams next time the user sees the page.
It seems like jsPlumb, paperjs, and raphael can all do this and a lot more, my question is which one is suitable for this need.
inspect graphiti which is based on raphael.
http://www.draw2d.org/graphiti/jsdoc/#!/example
Greetings
Andreas
Today I did something I've been meaning to do for a while. I got around to creating some icons for the two custom entities I created a while ago. These custom entities were Account Product and Contact Product. I used a microsoft tool to import and publish the new icons. This seemed to work ok. The problem is now the only icons that show up in the entire CRM are the two new icons. All the rest are just blank with little red dots. This isn't the case on the computer I made the change from. All icons are present there. But from every other computer all icons are missing. I seems to be some sort of permission thing but I'm blowed if I know know what it is.
Please help. Any ideas?
Image available here http://i244.photobucket.com/albums/gg14/chimpsinties/Temp/Clipboard01.jpg
Here is the post I followed with a link to the tool http://mscrmtools.blogspot.co.uk/2010/04/updating-custom-entities-icons.html
I have seen that sort of image in Dynamics when you need to publish all the customisations.
I'm going to be honest: this is a question I asked on the Django-Users mailinglist last week. Since I didn't get any replies there yet, I'm reposting it on Stack Overflow in the hope that it gets more attention here.
I want to create an app that makes it easy to do user friendly,
multiple / mass file upload in your own apps. With user friendly I
mean upload like Gmail, Flickr, ... where the user can select multiple
files at once in the browse file dialog. The files are then uploaded
sequentially or in parallel and a nice overview of the selected files
is shown on the page with a progress bar next to them. A 'Cancel'
upload button is also a possible option.
All that niceness is usually solved by using a Flash object. Complete
solutions are out there for the client side, like: SWFUpload
http://swfupload.org/ , FancyUpload http://digitarald.de/project/fancyupload/
, YUI 2 Uploader http://developer.yahoo.com/yui/uploader/ and probably
many more.
Ofcourse the trick is getting those solutions integrated in your
project. Especially in a framework like Django, double so if you want
it to be reusable.
So, I have a few ideas, but I'm neither an expert on Django nor on
Flash based upload solutions. I'll share my ideas here in the hope of
getting some feedback from more knowledgeable and experienced people.
(Or even just some 'I want this too!' replies :) )
You will notice that I make a few assumptions: this is to keep the
(initial) scope of the application under control. These assumptions
are of course debatable:
All right, my idea's so far:
If you want to mass upload multiple files, you are going to have a
model to contain each file in. I.e. the model will contain one
FileField or one ImageField.
Models with multiple (but ofcourse finite) amount of FileFields/
ImageFields are not in need of easy mass uploading imho: if you have a
model with 100 FileFields you are doing something wrong :)
Examples where you would want my envisioned kind of mass upload:
An app that has just one model 'Brochure' with a file field, a
title field (dynamically created from the filename) and a date_added
field.
A photo gallery app with models 'Gallery' and 'Photo'. You pick a
Gallery to add pictures to, upload the pictures and new Photo objects
are created and foreign keys set to the chosen Gallery.
It would be nice to be able to configure or extend the app for your
favorite Flash upload solution. We can pick one of the three above as
a default, but implement the app so that people can easily add
additional implementations (kinda like Django can use multiple
databases). Let it be agnostic to any particular client side solution.
If we need to pick one to start with, maybe pick the one with the
smallest footprint? (smallest download of client side stuff)
The Flash based solutions asynchronously (and either sequentially or
in parallel) POST the files to a url. I suggest that url to be local
to our generic app (so it's the same for every app where you use our
app in). That url will go to a view provided by our generic app.
The view will do the following: create a new model instance, add the
file, OPTIONALLY DO EXTRA STUFF and save the instance.
DO EXTRA STUFF is code that the app that uses our app wants to run.
It doesn't have to provide any extra code, if the model has just a
FileField/ImageField the standard view code will do the job.
But most app will want to do extra stuff I think, like filling in
the other fields: title, date_added, foreignkeys, manytomany, ...
I have not yet thought about a mechanism for DO EXTRA STUFF. Just
wrapping the generic app view came to mind, but that is not developer
friendly, since you would have to write your own url pattern and your
own view. Then you have to tell the Flash solutions to use a new url
etc...
I think something like signals could be used here?
Forms/Admin: I'm still very sketchy on how all this could best be
integrated in the Admin or generic Django forms/widgets/...
(and this is were my lack of Django experience shows):
In the case of the Gallery/Photo app:
You could provide a mass Photo upload widget on the Gallery detail
form. But what if the Gallery instance is not saved yet? The file
upload view won't be able to set the foreignkeys on the Photo
instances. I see that the auth app, when you create a user, first asks
for username and password and only then provides you with a bigger
form to fill in emailadres, pick roles etc. We could do something like
that.
In the case of an app with just one model:
How do you provide a form in the Django admin to do your mass
upload? You can't do it with the detail form of your model, that's
just for one model instance.
There's probably dozens more questions that need to be answered before
I can even start on this app. So please tell me what you think! Give
me input! What do you like? What not? What would you do different? Is
this idea solid? Where is it not?
Thank you!
I just released a simple app for this about a month ago: django-uploadify.
It's basically a Django template tag that acts as a wrapper for the very nifty Uploadify (requires jQuery). Using it is as simple as adding this to your template...
{% load uploadify_tags }{% multi_file_upload ‘/upload/complete/url/’ %}
The tag will fire events (1 per file) on both the client-side and server-side (Django signal) to indicate when an incoming file has been received.
For example, assuming you have a model 'Media' that handles all user-uploaded files...
def upload_received_handler(sender, data, **kwargs):
if file:
new_media = Media.objects.create(
file = data,
new_upload = True,
)
new_media.save()
upload_recieved.connect(upload_received_handler, dispatch_uid=‘whatever.upload_received’)
Check out the wiki for info on how to set it up and create the signal handlers (client/server).
About your conceptual implementation from above, here's a few points of consideration:
Having the app automatically create the "File Model" instance probably isn't as robust as people may already have their own models they're working with
If you want to implement any type of security or authentication, you need an open system and less of an 'auto-create' type
I really think signals/events are the way to handle this, and also handle the 'DO OTHER STUFF' part of what you mentioned.
My conclusion was that multi-upload can never really be a form widget in the sense that Django implements form widgets. 1 file will most likely be represented by 1 model instance (with some exceptions), which means that we end up with a situation where 1 widget can represent N model instances. However Django is setup so that a widget represents 1 value for 1 field in 1 instance. It just doesn't fit for the majority of use-cases to have it as a widget (hence why I went the template tag route).