Closed. This question needs to be more focused. It is not currently accepting answers.
Want to improve this question? Update the question so it focuses on one problem only by editing this post.
Closed 8 years ago.
Improve this question
This year I need to finish my bachelor theses, and my task is to create a game known as checkers(or draughts). It wouldn't be a problem, but I have to write it in NetLogo using the Mutli-agent approach. So I cant use those well-known algorithms as Min-max or alfa-beta pruning. As I said, I have to use the Multi-agent approach, because in NetLogo every single piece is an agent, and they can communicate with each other. So as my teacher said me, I have to create a completely new algorithm. Could someone give me any advice or suggestion how to start, or describe it how it should work?
You can get ideas from this model and get started to develop your own:
CHECKERS by ALBERT LEE MCS1 PD. 5
This is the board game checkers. It follows the same rules as regular checkers, but without double-jumps, or triple-jumps, etc. The goal of the game is to jump every single of your opponent's pieces. Jumping pieces is done by jumping diagonally, over an opponent's piece. Only one color of the board is used for moving. Players take turns moving. On a regular move, when you don't want to jump an opponents piece, movement of one diagonal space is allowed. A red piece can only move in the direction toward the black pieces when the board is set up, and the black pieces do likewise. However, when either player's pieces get to the other end of the board, they become a king, known as "kinging," and either color king can move both forwards and backwards. The same one diagonal space rule applies, unless the king jumps, which it can jump also either forwards or backwards.
In my program, there are two steps to moving. First, you select the piece with your mouse. Then, you select the patch that you want to move the piece to. If you select a piece and select another piece instead of the patch, instead of moving the initially selected piece to that new piece, the new piece becomes selected, and the same rule of moving applies. To jump a piece, select the piece you want to jump with, and if the piece you want to jump is "jumpable," which means that the piece you want to jump with is one space diagonally with the piece you want to jump, and the next patch in that direction has no pieces. After selecting the piece you want to jump with, select that patch with no pieces. The "jumped" piece leaves the board.
Related
let's say that i have a Blender Snake Model , what is the best practice to move it and bend it while collided like a real snake body. i tried to divide it but using the InvokeRepeating() gave it the old school snake game movement plus a bad harmony between the inputs(update) and the InvokeRepeating(), also i did the part follow the previous part method but it's have some glitches while rotating and distances problems. so is there any other good practice ??
this is an image from google of how a snake (model) looks like XD and how the movement looks like ex of a bended snake Model from google
Possible solutions
Solution 1
Use rope-like physics and experiment with which parts of the snake must invoke movement and which parts must only be moved by the other parts. As well as how much each part should move.
In this situation you may benefit from making weight points in the snakes body parts, to make it seem more realistically moving.
Solution 2
Another way to somewhat achieve it would be to make the classes SnakeHead, SnakeBody and SnakeTail.
When Snakehead then moves, he afterwards tells the nearest body part to move, which tells the next body part to move and so on till you reach the tail.
That way you can have them move closer to where the body part in front of them was a moment ago.
Solution 3
Follow this tutorial: https://www.youtube.com/watch?v=xz8Ga9er3_8&feature=youtu.be
I just started (yesterday) using unreal engine and I need to simulate a drunk character using BPs.
I'm using two camera shakes (one for standing still and one for walking) but I want to add some "displacement" on charater when he's walking.
Basically I want to define a random float to be added to X axis location in order to make character wobble smoothly.
It will be acceptable even if there's a way to make the character move along with the camera when it's shaking.
What I tried until now is using AddActorLocalOffset and a timeline to lerp between actor's location and actor's location+offset, but both are very choppy to me.
Maybe it's a noob question but as I told I'm very new to this and need it for a quick work.
Any suggestion?
Thanks
If you are targetting physically correct model, you should use AddForce (UE Docs). But this approach would require implementation of a "drunk animation" where your character will modify it's movement animation to "compensate" this force by stepping aside etc.
Another (much more simple) approach is by using AddMovementInput. This example can be seen here: UE Aswers. In this case, you are basically simulate player's input by adding small amount of side force here and there.
I,m creating a dungeon generator in unity3d. I have a pile of prefabs(rooms, corridors, junctions). Randomly a piece is chosen for starting piece and then depending on the connecting rules next pieces are chosen. Also the dungeon can be multi layered. Like 1 room above the other etc. Problem is room collisions. On the same layer 2 rooms can be placed on top of each other and this is a problem.
My first idea was to use arrays to model the layers and then find best suiting locations for stairs up and down. But the problem with this is that not all angles are 90degrees. I have a 3 way intersection in the shape of Y. So everything that comes after this is angled. And its not easily represented on array.
Second idea was the use of collisions and backtracing. I place the tile and then if no collision I can move forward. But if collides I try to find a better suiting piece or remove the previous piece and but something new there. But I can't figure out a good method to do this.
Anyone have any suggestions or ideas on how to generate multilayered dungeons with non 90 degree angles?
I am developing (or atleast trying to develop)
a decently big real time tactics game (something similar to RTS) using SpriteKit.
I am using GamePlay kit for pathfinding.
Initially I used SKActions to move the sprites within the Path but fast enough I realized that it was a big mistake.
Then I tried to implement it with GKAgents (this is my current state)
I feel that GKAgents are very raw and premature also they are following some strange Newton Law #1 that makes them to move forever (I can't think of any scenario where it would be useful - maybe for presentations at WWDC)
as well as I see that they have some Angular speed to perform rotations
which I don't need at all and can't really find how to disable it...
As well as GKBehaviors given a GKGoals seems to make some weird thing...
Setting behavior to avoid obstacles makes my units to joggle around them...
Setting behavior with follow path goal completely ignores everything unless the maxPredictionTime is low enough...
I am not even willing to tell what happens when I combine both them.
I feel broken...
I feel like I have 2 options now:
1) to struggle more with those agents and trying to make them behave as I wish
2) To roll all the movement on my own with help by GKObstacleGraph and a path Finding (which is buggy as well I have to say at some points the path to the point will generate the most awful path like "go touch that obstacle then reverse touch that one then go to the actual point (which from the beginning could be achieved by a straight line)").
Question is:
What would be the best out of those options ?
One of the best ways (in SpriteKit/GameplayKit) to get the kind of behavior you're after is to recognize that path planning and path following need not be the same operation. GameplayKit provides tools for both — GKObstacleGraph is good for planning and GKAgent is good for following a planned path — and they work best when you combine the strengths of each.
(It can be a bit misleading that GKAgent provides obstacle avoidance; don't think of this in the same way as finding a route around obstacles, more like reacting to sudden obstacles in your way.)
To put it another way, GKObstacleGraph and GKAgent are like the difference between navigating with a map and safely driving a car. The former is where you decide to take CA-85 and US-101 instead of I-280. (And maybe reevaluate your decision once in awhile — say, to pick a different set of roads around a traffic jam.) The latter is where you, continuously moment-to-moment, change lanes, avoid potholes, pass slower vehicles, slow down for heavy traffic, etc.
In Apple's DemoBots sample code, they break this out into two steps:
Use GKObstacleGraph to do high level path planning. That is, when the bad guys are "here" and the hero is "way over there", and there are some walls in between, select a series of waypoints that roughly approximates a route from here to there.
Use GKAgent behaviors to make the character roughly follow that path while also reacting to other factors (like making the bad guys not step on each other and giving them vaguely realistic movement curves instead of simply following the lines between waypoints).
You can find most of the relevant stuff behind this in TaskBotBehavior.swift in that sample code — start from addGoalsToFollowPath and look at both the places that gets called and the calls it makes.
As for the "moving forever" and "angular speed" issues...
The agent simulation is a weird mix of a motivation analogy (i.e. the agent does what's needed to move it toward where it "wants" within constraints) and a physics system (i.e. those movements are modeled like forces/impulses). If you take away an agent's goals, it doesn't know that it needs to stop — instead, you need to give it a goal of stopping. (That is, a movement speed goal of zero.) There might be a better model than what Apple's chosen here — file bugs if you have suggestions for design improvements.
Angular speed is trickier. The notion of agents' intrinsic physical constraints being sort of analogous to, say, vehicles on land or boats at sea is pretty well baked into the system. It can't really handle things like space fighters that have to reorient to vector their thrust, or walking creatures that can just as happily walk sideways or backwards as forward — at least, not on its own. You can get some mileage toward changing the "feel" of agent movement with the maxAcceleration property, but you're limited by the fact that said property covers both linear and angular acceleration.
Remember, though, that the interface between what the agent system "wants" and what "actually happens" in your game world is under your control. The easiest way to implement GKAgentDelegate is to just sync the velocity and position properties of the agent and the sprite that it represents. However, you don't have to do it that way — you could calculate a different force/impulse and apply it to your sprite.
I can't comment yet so I post as an answer. I faced the same problem recently: agent wiggling around the target or the agent that keeps moving even if you remove the behavior. Then I realized that the behavior is just the algorithm controling the movement, but you can still access and set the agent's speed, position and angle by hand.
In my case, I have a critter entity that chases for food in the scene. When it makes contact with the food agent, the food entity is removed. I tried many things to make the critter stop after eating the food (it would keep going in a straight line). And all I had to do was to set its speed to 0. That is because the behavior will influence not the position directly, but the speed/angle combination instead (from what I understand). When there is no goal for the entity, it doesn't "want" to change it's state, so whatever speed and direction it reached, it will keep. It will simply not update/change it. So unless you create a goal to make it want to stop, it will wiggle/keep going. The easy way is to set the behavior to nil and set the speed to 0 yourself.
If the behavior/goal system doesn't do it for the type of animation you are looking for, you can still use the Agent system and customize the movement with the AgenDelegate protocol and the update method and make it interact with other agents later on. You can even synchronize the agent with a node that is moved with the physics engine or with actions (or any other way).
I think the agent system is nice to keep around since you can use it later, even if it's only for special effects. But just as mixing actions and physics can give some weird results, mixing goal/behaviors and any other "automated" tool will probably result in an erratic behavior.
You can also use the agent system for other stuff than moving an actual sprite around. For example, you could use an agent to act as a "target seeker" to simulate reaction time for your enemies. The agent moves around the scene and finds other agents, when it makes contact with a suitable target, the enemy entity would attack it (random idea).
It's not a "one size fits all" solution, but it's a very nice tool to have.
I'm trying to re-create a 'falling sand' simulation, similar to those various web toys that are out there doing the same thing - and I'm failing pretty hard. I'm not really sure where to begin. I'm trying to use cellular automata to model the behavior of the sand particles, but I'm having trouble figuring out how to make the direction in which I update the 'world' not matter...
For example, one of the particle types I'd like to have is Plant. When Plant comes in contact with Water, Plant turns that Water particle into another Plant particle. The problem here though is that if I'm updating the game world from top to bottom and left to right, then a Plant particle placed in the middle of a sea of Water particles will immediately cause all of the Water particles to the right and below that new Plant particle to turn into Plants. This is not the behavior I am expecting. =(
One straightforward solution is to not do each iteration in-place. Instead, every time you update the world, create a copy of it... then look at the original, but update the copy. That way the order of updating does not matter any more, because you are completely disregarding your updates while you're looking for particles.
Don't program it in a sequential way (looping over all particles) but use real simulation programming techniques in which every particle is treated as an individual object/agent that obeys the laws of physics and that can act (run) asynchronously and respond to "events" (interactions with other particles).
If making every sand particle a separate object is too fine-grained, then divide the world into small blocks of let's say 1000 particles and simlute the behavior of these blocks instead.