--- exec-maven-plugin:1.2.1:exec (default-cli) @ cardshifter-fx ---
java.net.NoRouteToHostException: No route to host
at java.net.PlainSocketImpl.socketConnect(Native Method)
at java.net.AbstractPlainSocketImpl.doConnect(AbstractPlainSocketImpl.java:345)
@SimonAndréForsberg It's not hard to test them, unit testing would be hard... But integration tests are there to ensure features work (like enchanting, then you need to use a specific trace that goes through enchanting)
@SimonAndréForsberg You've got to do those either way, unit tests are nice and all, but you need to test an actual execution as well... preferably with as many elements as possible
@SimonAndréForsberg I am trying to do new Thread(this::play).start(); and it says "incompatible thrown types IOException, InterruptedException in method reference"
If you input an IP adres that is malformed, then I call it simply a programmer error, as it should not have been malformed, it's the same as a IllegalArgumentException
@SimonAndréForsberg I have this code inside of CameClientLauncherController, it successfully runs switchToMainGameWindow and it calls closeWithSuccess, but it does not actually close the launcher window:
private void buttonClick(ActionEvent event) {
//Get values from the TextFields
String ipAddressValue = this.getCharactersFromTextField(ipAddressBox);
int portValue = Integer.parseInt(this.getCharactersFromTextField(portBox));
//Attempt to make a connection
try {
//Send a test to the server, to make sure that it is valid
//if it is valid
errorMessage.setText("Success!");
this.switchToMainGameWindow(ipAddressValue, portValue);
this.closeWithSuccess(event);
} catch (Exception e) {
@skiwi @bazola I personally more and more feel that the ECS approach is the way to go, I have a nice little 'framework' for it and the "Phrancis-game" is nearly finished. It is possible to use varying levels of abstraction when doing this (I tend to perhaps use a little bit more than needed), but I feel that it is very powerful and flexible. I do wonder though: Will we end up using it or not?
@SimonAndréForsberg well I am definitely open to ECS. I do not know how I would change the client/server model to work and pass all the information back and forth between the client and the server, so if you have that solved in ECS then it definitely has a huge advantage versus our other code base
as long as you think the rest of us can understand it :)
Entities has component stored on them. Components are mostly data. Systems, in this variant, listens for events and perform stuff on entities and their components.
> When a build status update occurs on a tag, then it incorrectly references a branch: [Cardshifter/Cardshifter] build #73 for commit 9197797e on branch 0.1 passed
one thing that helped me understand it was that you use the Components as Keys to access the data, so an Entity may have Component1 and Component2, and the system looks through and says, If an Entity has Component1 and Component2, then I will perform these operations on those Components. Otherwise the system will ignore those components (unless they match what the system is looking for)
A component is data. Information stored about entities.
Zones are components. A Card is a component (a player is also an entity, but cannot move between zones like a card does)
Another component example is PlayerComponent, that are stored on player-entities. There is also a 'CreatureType' component that can be stored on creatures that indicates a specific creature typ (Mechanical Bot, Beast, Alien, etc...)
ActionComponent for storing information about available actions that a player have.
Systems/Listeners ----------------- When game is first started, they can do some 'setup work', such as making a player draw a specific amount of cards. Often systems only add a listener when game is started, so that it is alerted when something happens, such as a card is drawn, a resource value is changed.
Example systems: AttackYGOSystem, AttackHearthstoneSystem (Switch between them by only changing one line of code!) LimitedPlaysPerTurn - Can be used to limit a player to only do a specific number of actions per turn.
@SimonAndréForsberg what exactly sends the message to the console "Waiting for opponent" and how does the NetworkConsoleController know how to output that
> Travis is still running on Java 8u5, we should force it to update to the most recent version, github.com/skiwi2/JavaLuaInteropTest has the code for that task somewhere.
@skiwi Here's a description about the moddability:
How to make a mod? ------------------ Creating a mod requires almost no programming experience at all. Because there is a number of possible systems available already, making a mod becomes almost a matter of *configuration*
If you feel that some component/system is missing, then it is not too hard to hook into the ECS API and make your own component/system. Components and systems can also hook into Lua (although it is easier to make them in Java directly), you can have a Component that stores a LuaTable for example, and a system that calls a LuaFunction.
public class DrawCardTakeDamageSystem implements ECSSystem {
private final int damage;
private final ResourceRetreiver resource;
public DrawCardTakeDamageSystem(ECSResource resource, int damage) {
this.damage = damage;
this.resource = ResourceRetreiver.forResource(resource);
}
@Override
public void startGame(ECSGame game) {
game.getEvents().registerHandlerAfter(DrawCardEvent.class, this::damage);
}
private void damage(DrawCardEvent event) {
resource.resFor(event.getOwner()).change(-damage);
See the 'JavaFX in Swing' tutorial. You are performing JavaFX operations which should run on the JavaFX thread on the Swing thread (Event Dispatch Thread).
Luckily they learnt from their previous mistakes and now throw exceptions when you perform operations on the wrong thread. That is the excep...
(Although the "in Swing" part is totally irrelevant to the subject)
well in the real world you would not want to hard code the IP for connecting, so I built a UI to input that information, which may be useful when we are testing real games against each other, but is actually a hindrance when trying to test by myself to get a GUI client working
Start loop
Enter your name:
Sending: {"command":"login","username":"Player37"}
iterator: com.cardshifter.server.outgoing.WelcomeMessage@63093aa6
OK
Sending: {"command":"startgame"}
iterator: com.cardshifter.server.outgoing.WaitMessage@26d3e7c0
Waiting for opponent...
i just think it is strange having to commit and push again after every pull, but I guess that is just how it works. But what should I be putting as the message when I do so? is there standard practice for that?
@bazola Whenever I do so, I get an automatic commit message. It also seems that you do some kind of rebase instead of a merge, that is quite interesting...
> Refactoring GroupValues and FieldGroup to use composition over inheritance will make the usage of those classes clearer, and will help in improving the performance. GroupValues uses the non-primitive Integer for example, while a good old int would suffice.
i have to make it do something like ask the server for a message, and then wait until the player sends input from the GUI. I think I can make that work with some more work
if you add some more mess instanceof checks in the while loop, for ZoneMessage, CardMessage and some others, and paint stuff in the GUI when your receive those messages, then you will probably have better progress.
Don't focus on parsing the text, Jackson takes care of that. All messages gets instantiated as a **Message class
