yoel123 / godot-yoel-space-sim-game Goto Github PK

can be created using a mesh and a raycast (to get the start and end point).

as for game/gameplay functionality, i don't want freespace like laser cannons, in my game the continues laser will be weak, used as point defense aginst rockets and bombs, it will be weak against shields so its not overpowered against fighters, another nerf will be that it will take a lot of energy so it will have a short use (like a 5-7 second timer). can be confused by flares as flares create both heat and aspect enough to confuse automated defenses.

basically its a protected energy weapon, unlike the other laser "bullets".

as of now a player has no reason to stop shooting as the weapon has limitless ammo.

to make him conserve his shot we can add in "weapon.gd" a "overheat" mechanic where after shooting a couple of shots the weapon will heat up.

it wouldn't stop shooting,but it will not shot rapidly, lets say you have 10 shots, when there less a shot regenerate at 1 second rate, so if you waste all the 10 shots you will shot once a second.

different ships will have different ammo regen rates based on their reactor, which is limited as its a small ship. some weapons will have higher reserves like 30 shots before its slowed down.

and make sure the heat up option is optional add a flag( boolean attribute/var) "is_heat_up" so if its false the heat up function wont run (like in ships that don't need this feature).

this is an anti-fighter turret. if you dont know how flak canons work search for vids on youtube.

basically, its a canon that shots an explosive round full of shrapnel, when it explodes it has a grenade like effect but for fighter planes. any fighter caught in the shrapnel radius will be damaged. this makes hitting fighters easier as you don't need to precisely aim or track the target. a heavy flack screen will at least disrupt incoming fighters.

in effects terms its an explosion effect, please use a different one then the one I created.

in code terms, it aimes at the fighters position + velocity (weapon.gd have a "make_bullet_ai" method that does this) after a short time (make a timer) the flak bullet will explode, the explosion will have an area with a collation shape, any fighter in that area will take random damage. its great aginst fighters missiles and bombs.

it doesn't have a large range.

don't make it too effective.

will use "fighter.gd" or inherit from it,as it ha most functions.

for its movement: it stays around its parent big ship and flocks in formation around other drones.
if it detects a threat (enemy ship,torpedo,bomb,rocket)it will move towards it and try to shot it.
it will even kamikaze on bombs if their too close.

shooting:: it can shot regular laser, some drones shot dumb fire rockets,some shot smart fire rockets. they all have one weapon.

they don't have shields.

again as the title says.

most weapons will have the same functionality, be it fire rate timer, damage , damage types, shooting an object (bullet, missile what ever).

the difference between weapons will mostly be data, since I'm planning to have more then a few the best way to do it is keep all the data in one place.

this will also make adding and changing weapons simpler,like adding and/or changing a data row.

lets say a row will look something like that:

[weapon name(string),bullet type(string),dmg(int),fire rate(int),is secondary(bool),is ammo based(bool),max_ammo(int)]

bullet type: when the weapon shots it generates an object (a godot scene) be it a laser or missile, the bullet type will determine which
object will be generated (by the bullet factory object).

is secondary: a ship has a primary and secondary weapons,activated by different btns.

is ammo based: some weapons are ammo based this flag will determine this.

might add damage type and spread,this will make it easier todo and maintain.

i will use a json like object to hold the db, it will be add to the global scripts the protect calls.

and as I mentioned there will be a method in weapon to set a weapon stats by name (it will call the row with the weapons name).

an explosion effect will create an area damage, use an actual area for that, it will damage all objects inside its collation shape and remove itself.

same as a normal ship in terms of code.

the only difference is how it looks/moves. and it has 0 shields.

maybe a big thing will be made of objects that look at and follow a head object like a snake.

these are flares that fighters shot near big ships, their goal is to confuse turrets and any other defenses that need to automatically lock on a fighter, the flares has the same heat and aspect of a fighter.

this will let fighters get close as the big ship defenses focus on some of the flares(and cant distinguish between flares and fighters).

in code it means that hardpoints will add flares as potential fighter targets and shot at them.

their numbers is limited on a fighter, bombers shod carry more of these it will give them a tactical advantage.

its a secondery weapon, that spawns a mini turret that shots a laser at the closest target.

does little damage as it shots one laser. has low hp.

one of these cant change a fight, 5 of these is a different story.

an object that creates and adds a ship into the game.

you put it somewhere in the game, and after a timer or event happens its spawns a ship.

an event can be : reached a location or, some target has been destroyed.

this can make level making easier for whoever designs the level plus no code is needed.

the object will have these variable fields:

-a select box for type
-an input for timer
-an input for target (to check if its destroyed)

when taking damage check the ships armor class: light, normal, heavy, ultra heavy.

the better the armor the less damage the ship takes.

big ships and capital ships have better armor then any fighter or bomber, their armor is above ultra heavy.

most light fire projectiles will barely damage a warship (or any armored big ship).

with the exception of torpedos and bombs (or the strongest fighter laser) who are made to damage big ship armor.

a big ship shod have areas of damage for important systems like weapons,engine,command bridge.

if destroyed some of the ships functionality will be disabled.

if engines is destroyed it cant move,if weapons it will shot much less effectively and some of its turrets will come offline.
if command bridge is destroyed its overall effectiveness will go down or even get stunned for a short amount of time.

the player shod be able to target subsystems or at least have an indication of their status and location.

this one is not easy to conceptualize or implement, consult me before you work on it.

colony wars don't have this feature but its still a fun game.

when ships hit each other they take damage, damage is dependent on mass and speed.

if you have any other way to do this I'm ok with that as long as its good.

we have a homing missile, generally, these fly much faster than any fighter,so evading it is close to impossible.

for that we need a counter measure system.

when a homing weapon is locked on a fighter a counter measure shod be deployed,the homing lock will pass from the missile to the counter measure, if 10 missiles are locked on a fighter and a counter measure is launched, all of them will lock on the counter measure.

the player will have to deploy it manually, the ai will do it automatically.

the number of counter measures are limited.

if you don't understand anything contact me.

basically, the ai aim is very good. i dont want all enemy fighter pilots to be aces, I also don't want big ships to be impossible to come close to.

so there will be an attribute in "fighter.gd" for pilot skill, this will affect the fighter ships accuracy, also when a "good pilot" gets hit he will try to evade the attacker on his tail and not move in a straight line when attacking or evading.

maybe more experienced fighters will use teamwork manuvers,like one will be bait and the other one will ambush whoever took the bait.

if you have other ideas I would like to hear them.

for turrets/hardpoints make them miss more often (for dumb fire turrets).

its basically implemented in missiles(the code for movement and collision).

what i want is a smaller rocket that supplements the laser fire (you shot it at the same time your ships cannons shot).

it has limited ammo doesn't deal good damage against shields. but it raises a fighters dps and if you shot unshielded targets they will take much more damage.

it also doesn't have heat up, its only limited by ammo.

great aginst fighters and hardpoints at close range.

it will be a fighter secondary weapon that targets big ships hardpoints only.

except for damage what it will do is disable that hardpoint for a while, giving the fighters and bombers more time to destroy it, which will result in making the big ship more vulnerable.

its another anti big ship tactical weapon, its kind of like flares.

this combined with flares can help take out big ships easier, your only worry will be interceptors and other fighters.

its a new scene that is like the turret hardpoint,except it will have a different modal.

its a turret that shots homing missiles at enemy fighters.

use the same nodes: placeholder,area with collision shape,ray for raycast.

you will need to edit these scripts: "ship_hardpoint.gd" and probably "weapon.gd" (so make it shot missiles).

attach it to the big ship and test if it works.

will need these two implemented, the afterburner by manipulating a particle emitter, the trail can be done by manipulating a basic mesh.

will require a little code.

both of these will be useful for engines and rockets etc.

i can do it myself, but Its a good issue for anyone that wants to contribute.

update:
already done, if you can improve how it locks and functions there will be a bounty for this.

its a big ship hardpoint for destroying missiles only, basically a point defense system (like a phalanx cannon).

it only targets bombs and missiles at reletive close range.

basically, a copy-paste from the enemy (fighter.gd) take damage.

here the interesting part is making a better explosion, maybe multiple explosions? debris after it gets destroyed?

for now the big thing is the logic part, I will open another issue for the effects.

its a medium range weapon against fighters.

it dosnt deal much damage,not that good aginst shields.

but its shot and forget(it homes on the closest target with priority to flares),has a high firate.

you carry a lot of these so they can be spammed.

doesn't have too much range because of its size.

the code for homing and damage dealing\collition is already implemented in "missile.gd" use it.

basically a fighter.gd with 0 speed.

you will mostly need to create a scene for it,make sure it works right: rotates,shots,takes damage etc.

its a turret dropped in space, shots hostile targets, meant for defensive tactical operations.

shod be very easy,with the available framework.

make is so a big ship hardpoint can get hit by bullets and be destroyed.

its easy because others a code for damage handling in "fighter.gd",you just need to adjust it a little.

plus once destroyed a timer starts, when its done the turret is fixed with full hp and is active a gain.

when destroyed,make it not visible and place an explosion, so the player knows its destroyed.

just another feature that will help with testing gameplay elements.

it will have "cheats" like god mode.

a couple of commands for spaning objects near the player ship for testing.

a command that will freeze all ships and bullets except for the player so the devloper/tester, can move around and see stuff and then unfreeze.

this may help replcate situations that can cause bugs etc.

and a command that outputs objects attribute values, and method that lets the developer log stuff on the console (even if godot already has a console log for that).

the console can be made with godots GUI nodes, others a couple of these consoles around.

same as the laser one but with a small missile hardpoint

a modular object that can be attached to big ships.

this object can spawn small ships (fighter bombers) at its position. it has a limited number.

damaged fighters can also retreat to their "home base".

the player can also retreat into a friendly bay for rearming and repairs.

maybe it will even be a mission objective to get to a big ship's hangar.

when a missile hits anything i want a particle emitter to be spawned where it hit (the missiles position).

some anti ship missiles don't explode, but once in the ships hull their fuel alone can burn a whole ship from the inside, especially if it hit an important system.

my game will have a torpedo that does slow "poison" overtime damage once a "fire torpedo" hit a big ship, there will also be a timer to check if the fire was put out.

these can be launched from big ships or bombers.

and can be destroyed by point defense or interceptors.

the first step will be to refactor "point_to_target()" in "player.gd" file to two functions, one for getting the target (searching for a target) and one for the pointer.

another thing is creating a the GUI to display the target name and stats.

adding a way to alternate between targets, like one button to go to the next target and one for previous target.

also make sure the target is from team 2 or not from the players team.

when a missile is locked on a target send its target a signal every 3 seconds.

basically, the missile will try to call a "missile lock" method of its target every 3 seconds (with a timer)

for the player it will be a ping noise notice, for a fighter it will mean lunch a flare (once), for a big ship it will tell one of its turrets to shot the missile (a point defense capable hardpoint) or lunch flares.

for a big ship maybe also tell nearby fighters/interceptors to defend it.

as the title says, i want to put all movement behaviors in the same place so they can be used in a more modular way.

that way I can use movement methods/functions wherever I need stuff to move.

and it will remove any math calculation out of object scripts, I prefer seeing logic code rather then bare math in object scripts.

this will help change math stuff in the future easier.

overall it shod make the project more readable and easier to maintain.

that way it will be easier to read "fighter.gd" and use ai scripts anywhere.

an example will be ai.move_to_random_spot(self).

we pass "self" so we can access and manipulate the objects attributes and methods etc.

same thing i did with "weapon.gd" which is used by player fighter and turret scripts.

this is the screen the player will be sent to when the game start or after the level is done.

before the player starts a level he will have a briefing after the level is done he will have a debriefing.

both will have the same function, a sound file with a narrator explaining the mission, a rich text area that will add text by a timer (a skip btn to skip the text being added by timer).

there will be a place for an image to show the level "map", for briefings visuals.

a text area for the goals/objectives.

in debriefing there will be no map but there will be a place for medals if the player unlocked an achievement or did a bonus objective.

maybe a whole ship as an improvised explosive device.

fighters and ships shod scatter when something like that comes close (if they can).

what the title says for the player ship.

and a button to change between these views.

basically when player hits space or left click(either is fine) shot secondary weapon.

the secondary weapon can be a dumb fire or homing rocket.

secondary weapon will have limited ammo.

it will use weapon.gd script (create new functions and attributes for it if needed).

contact me for any questions.

to be able to shot at a distant target you need to calculate where its going to be also called "leading".

in games like this x3 etc (there they call it "target lead indicator") there is usually a small green rect in front of where the target is going to be,and if you aim at that you will hit the target.

i never coded anything like it and there isn't seem to be any example or tutorial on the subject.

i have an idea on how to do it but I would like someone else to give it a go and take the credit.

it will not make or break the game but its a nice addition.

update:

wrote something like that that tracks the position+velocity of the enemy.

it works.

if anyone thinks he/she can do it better I'm open to suggestions.

i called it "targeting_helper" its a .gd file and a scene with a 2d sprite.

basically, a big ship that dosnt move has a ton of health and a lot of turrets.

used as a stationery fortress/stronghold.

a strategic target,as it controls an area in space.

a tactical advantage as it has a ton of firepower,hard to destroy, and provides support for friendly targets.

there shod be a weapon that targets only big ships. deals a ton of damage moves a bit slower.

basically its like the basic hardpoint but shots a different "bullet" and only targets big ships.

its a fighter secondary weapon meant to disrupt big ships anti fighter hardpoints.

unlike regular flare his one is launched at a big ship and flies around it, it has the same heat and spectrum signature as a fighter (in code functionality it means it uses the "fighter.gd" script but without a weapon).

this will make the hardpoints lock on the flares instead of the fighters, the sensors cant tell it apart from a fighter.

all this makes assaulting a big ship less dangerous as its defenses doesn't focus on you, which gives you a window of opportunity to deal as much damage as possible.

lunching a screen of these before a wing of bombers makes a bombing run is ideal.

as I mentioned the flare can have the fighter.gd script(inherit from it), perhaps its movement behavior needs to change, it doesn't shot, it doesn't take damage (as its small and hard to hit), it has a life timer like a bullet.
hardpoints lock on the closest fighter anyway so no need to change the hardpoint "get target" code, the flare is technically a fighter.

a secondary weapon that shots a missile that disables a fighter for a few seconds, the fighter can't move or shot.

doesn't do any damage.

shod be easy to implement as we have a homing rocket functionality.

the only thing that needs to be changed is the take dmg function.

a button that boosts the ships speed up to 120% of its speed. in the hud there will be a matter for the rechargeable afterburner "reserve", when it runs out you cant use afterburners.

these reserves will recharge overtime.

a screen that lets you outfit your fighter and the fighters of wings you control.

the equipment and fighter class available will depend on the level and the player rank.

like if he's an ensign or low rank he can outfit only his fighter, if the player character is the cag he can outfit all the wings.

meaning the selection of fighter/bomber class and the main and secondary weapons.

maybe let the player also select the hardpoints for the friendly big ships (I'm not sure if that's needed but it will be fun).

all the data gathered from the GUI in this screen shod pass to the level and the level objects.

an easy issue, add a new weapon to the game, a blue laser, besides the color it flies faster then the regular laser and deals a bit more damage.

shouldn't be that hard to code

a map that shows a top view of visible battlefield from above.

it will show all allied big and small ships, it will also show all visible enemy ships and the enemy ships that are close to allies.

it will be a scene attached to the player, its main node is a control node.

to show the map the player clicks m and clicks m again to close it.

its script will get its info from its parent.

3d object represented in 2d: the x stays the same and the z axis will be the 2d y axis. as its a top view from 2d the 3d y axis doesn't matter.

contact me if anything is unclear.

when the ship explodes i want a couple of objects to replace it as debris, their color will be changed a bit.

the objects will be parts of the ships 3d modal cut into parts.

i think I will do this myself as its not that hard.

can be done with the godot csg features that support 3d meshes:

https://godotengine.org/article/godot-gets-csg-support/

a very basic script, the player clicks a button set targ attribute to closest target.

this can be done by getting all targets, looping them and checking which has the smallest distance to the players ship.

the principle is the same for both, either one bullet that has a small random rotation or a loop that creates a couple of bullets per shot.

this can make hitting stuff easy as some shots must hit.

the shotgun will have a very short range (low bullet life), and low firate so it wont be overpowered.

the scatter shot cannon is like a machine gun high fire rate and the scatter give it more of a suppression effect.

can be used on fighters and hard points.

need to make it so bullets will have a scatter rate.

i want to create a scatter gun its great for dogfighting.

and a short-range shotgun/flachet cannon can be interesting.