I need to make the player to enter a scenario where he is asked to answer a riddle if it is correct go next lvl if does not go back to the beginning
Related
So I am trying to make an online webpage board game hybrid of chess and Go where the player clicks on the board to place his/her pieces. My problem is, there are a lot of algorithms that come into play in order to make such a board game possible, that are difficult to write out myself. There are good npm packages that already have a lot of that sorted out (I'm thinking primarily of godash), but in order to use the algorithms the packages provide I believe I have to make some sort of data representation of the game, pass the data to the back-end, use the algorithm on it, and return the result to front-end.
The issue is that, just like chess, the game would require the player to make moves on the board in a relatively short amount of time. The question is, if I decided to make this API call with every move the player makes, would that make my game too slow/unresponsive? Do I have to knuckle down and code those algorithms in front-end so that the game isn't too slow?
You should look into the Websocket API. You can establish a session between your client and server without having to call your server each time a user plays
I'm a relatively inexperienced programmer, and recently I've been getting interested in making a Checkers game app for a school project. I'm not sure where I can start (or if I should even attempt) at creating this. The project I have in mind probably wouldn't involve much more than a simple AI & a multiplayer player mode.
Can anyone give some hints / guidance for me to start learning?
To some extent I agree with some of the comments on the question that suggest 'try something simpler first', but checkers is simple enough that you may be able to get a working program - and you will certainly learn useful things as you go.
My suggestion would be to divide the problem into sections and solve each one in turn. For example:
1) Board representation - perhaps use an 8x8 array to represent the board. You need to be able to fill a square with empty, white piece, black piece, white king, black king. A more efficient solution might be to have a look at 'bit-boards' in which the occupancy of the board is described by a set of 64-bit integers. You probably want to end up with functions that can load or save a board state, print or display the board, and determine what (if anything ) is at some position.
2) Move representation - find a way to calculate legal moves. Which pieces can move and where they can move to. You will need to take into account - moving off the edges of the board, blocked moves, jumps, multiple jumps, kings moving 'backwards' etc. You probably want to end up with functions that can calculate all legal moves for a piece, determine if a suggested move is legal, record a game as a series of moves, maybe interface with the end user so by mousing or entering text commands you can 'play' a game on your board. So even if you only get that far then you have a 'product' you can demonstrate and people can interact with.
3) Computer play - this is the harder part - You will need to learn about minimax, alpha-beta pruning, iterative deepening and all the associated guff that goes into computer game AI - some of it sounds harder than it actually is. You also need to develop a position evaluation algorithm that measures the value of a position so the computer can decide which is the 'best' move to make. This can be as simple as the naive assumption that taking an opponents piece is always better than not taking one, that making a king is better than not making one, or that a move that leaves you with more future moves is better than one that leaves you with less choices for your next move. In practice, even a very simple 'greedy' board evaluation can work quite well if you can look 2-3 moves ahead.
All in all though, it may be simpler to look at something a little less ambitious than checkers - Othello is possibly a good choice and it is not hard to write an Othello player that can thrash a human who hasn't played a lot of the game. 3D tic-tac-toe, or a small dots-and-boxes game might be suitable too. Games like these are simpler as there are no kings or boundaries to complicate things, all (well most) moves are legal and they are sufficiently 'fun' to play to be a worthwhile software demonstration.
First let me state, the task you are talking about is a lot larger then you think it is.
How you should do it is break it down into very small manageable pieces.
The reasons are
Smaller steps are easier to understand
Getting fast feed back will help inspire you to continue and will help you fix things as they go wrong.
As you start think of the smallest step possible of something to do. Here are some ideas of parts to start:
Make a simple title screen- Just the title and to hit a key for it to
go away.
make the UI for an empty checkerboard grid.
I know those sound like not much but those will probably take much ore time than you think.
then add thing like adding the checkers, keeping the the gameboard data etc.,
Don't even think about AI until you have a game that two players can play with no UI.
What you should do is think about: what is the smallest increment I can do and add that, add that and then think about what the next small piece is.
Trust me this is the best way about going about it. If you try to write everything at once it will never happen.
EDIT
I'm completely rewriting this since I realized it wasn't very clear what I needed.
So, I'm going to implement an online game. The idea is quite simple. All players have to answer the same set of questions that is downloaded from the server. To answer each question the player has a given amount of time that depends on question difficulty. The questions are presented one at a time. After the time to answer the current question elapses the next one is presented to the player. After the last question the client should display the leaderboard with the scores of all currently online players. The leaderboard is (of course) computed on server and clients should download it when the game finishes.
OK that's the idea. What I require is some suggestions on how to implement the whole client-server communication. I don't need details but just some ideas. Most important I'm not sure how client-server time-sync could work. It's important that all players have the same amount of time to answer each question. I also have a solution that is very simple but I'm not sure about possible pitfalls. What I have in mind is that when the player first connects (or when a new game starts) the client downloads the whole list of questions for current game. Also some time-sync messages are exchanged to get current game time. Then after questions and time-sync are known at the client, a local timer is started and the game runs completely offline. When the game finishes each client sends its own score/result to the server. When the leaderboard is ready the server sends it back to all clients. Once again a local timer could be used to know when a new game is starting and to download the new list of questions.
Please post your suggestions and comment my solution. Thanks
I have created a basic adventure game in prolog. The player starts with 0 points, and I want the points to increase as the player progresses in the game. How do I do this?
Pardon me if my question sounds stupid, I'm only a beginner in Prolog.
You can add facts at run time using:
asserta(...)
assertz(...)
asserta adds a fact on the top, so using the cut i think you can hide the previous value.
When I was in high school and learning about matrices, we were shown a technique that would help in a situation like this:
There are a number of chess players in a league, and they need to determine a ranking for all of them, but don't have enough time for every player to play every other person. If it ends up that Player A beats Player B, and Player B beats Player C, you can say with some level of certainty that Player A is better than Player C and therefore award some points to player A in lieu of them actually playing each other.
As I said, this was a little while ago and I can't remember how to actually perform the algorithm, but I think it was called something like a "domination matrix". Searching the web for that has been fruitless and scary at times, so I don't think that's right.
Can anyone give me some help? Ideally an algorithm I can use for this program I'm working on, but even just a pointer to some more information about the procedure.
It sounds like you are remembering a presentation of the Perron-Frobenius theorem - which is at least a safer search term :-). One such is at
http://www.math.utah.edu/~keener/lectures/rankings.pdf
Chess players use the Elo system, described at http://en.wikipedia.org/wiki/Elo_rating_system and http://www.chesselo.com/, which would be easier to implement. It is possible that there is no good ranking even if you know everything - see http://en.wikipedia.org/wiki/Nontransitive_dice. People modelling soccer games usually keep track of defensive and offensive strengths separately.
What it sounds like you are describing is a Swiss System tournament or a very similar variation all described on the linked Wikipedia entry. Although rather than given an incomplete tournament to calculate ratings it is a way to organize a tournament to pair the best chess players with the best and the worst chess players with the worst to determine a ranking without the need for everyone to play everyone else.
Maybe some type of PageRank algorithm might work for you.
Imagine every person has a webpage in which they hyperlink to every person who defeated them.
Running the page rank algorithm on this data would give you give you the steady state of your link matrix which might indicate to you the relative importance of each person (I guess).
For example a person who played only one game but, in that, defeated someone who defeated lots of people might have a higher page rank than somebody who defeated 10 people who in turn have not won a single game.
perhaps the min-max algorithm ?