Added psu_instance, a process to handle missions and more later.

ebin/egs.app

@@ -13,10 +13,10 @@
 		psu_game,
 		psu_login,
 		psu_patch,
+		psu_instance,
 		egs_proto,
 		psu_appearance,
 		psu_characters,
-		psu_missions,
 		psu_parser
 	]},
 	{registered, []},

include/network.hrl

@@ -20,13 +20,11 @@
 
 -define(PATCH_PORT_JP, 11030).
 -define(PATCH_PORT_US, 11230).
--define(PATCH_LISTEN_OPTIONS, [binary, {send_timeout, 5000}, {packet, 0}, {active, false}, {reuseaddr, true}]).
 
 -define(LOGIN_PORT_JP_ONE, 12030).
 -define(LOGIN_PORT_JP_TWO, 12031).
 -define(LOGIN_PORT_US, 12230).
--define(LOGIN_LISTEN_OPTIONS, [binary, {active, false}, {certfile, "ssl/servercert.pem"}, {keyfile, "ssl/serverkey.pem"}, {password, "alpha"}]).
 
 -define(GAME_IP, << 188, 165, 56, 119 >>).
 -define(GAME_PORT, 12061).
--define(GAME_LISTEN_OPTIONS, [binary, {active, false}, {certfile, "ssl/servercert.pem"}, {keyfile, "ssl/serverkey.pem"}, {password, "alpha"}]).
+-define(GAME_LISTEN_OPTIONS, [binary, {active, false}, {certfile, "priv/ssl/servercert.pem"}, {keyfile, "priv/ssl/serverkey.pem"}, {password, "alpha"}]).

include/records.hrl

@@ -32,7 +32,7 @@
 %% @todo Probably can use a "param" or "extra" field to store the game-specific information (for things that don't need to be queried).
 
 -record(egs_user_model, {
-	id, pid, socket, state, time, character, instanceid, areatype, area, entryid, pos,
+	id, pid, socket, state, time, character, instancepid, areatype, area, entryid, pos,
 	%% psu specific fields
 	lid, prev_area, prev_entryid,
 	%% temporary fields
@@ -98,7 +98,7 @@
 
 %% @doc Table containing all mission objects.
 
--record(objects, {id, instanceid, objectid, type, targetid, blockid, triggereventid, args}). % id = [instanceid, objectid]
+-record(psu_object, {id, instancepid, type, args}).
 
 %% @doc Hit response data.
 

src/egs_app.erl

@@ -70,6 +70,6 @@ db_init() ->
 	error_logger:info_report("starting mnesia"),
 	mnesia:start(),
 	mnesia:create_table(ids, [{attributes, record_info(fields, ids)}]),
-	mnesia:create_table(objects, [{attributes, record_info(fields, objects)}]),
+	mnesia:create_table(psu_object, [{attributes, record_info(fields, psu_object)}]),
 	mnesia:create_table(egs_user_model, [{attributes, record_info(fields, egs_user_model)}]),
 	error_logger:info_report("mnesia tables created").

src/egs_db.erl

@@ -19,56 +19,7 @@
 -module(egs_db).
 -compile(export_all).
 
--include("include/records.hrl").
-
-%% IMPORTANT: The next line must be included
-%%            if we want to call qlc:q(...)
-
--include_lib("stdlib/include/qlc.hrl").
-
-do(Q) ->
-	F = fun() -> qlc:e(Q) end,
-	{atomic, Val} = mnesia:transaction(F),
-	Val.
-
 %% @doc Retrieve the next unique ID.
 %% @todo Used only for the LID so far...
 next(Type) ->
 	mnesia:dirty_update_counter(ids, Type, 1).
-
-%% @doc Insert a new object in the database.
-%% @todo Group with users_insert, it's the same function really.
-
-objects_insert(Object) ->
-	mnesia:transaction(fun() -> mnesia:write(Object) end).
-
-%% @doc Select an object by ID.
-
-objects_select(ID) ->
-	case mnesia:transaction(fun() -> mnesia:read({objects, ID}) end) of
-		{atomic, []} ->
-			undefined;
-		{atomic, [Val]} ->
-			Val
-	end.
-
-%% @doc Select an object by instanceid and targetid.
-
-objects_select_by_targetid(InstanceID, TargetID) ->
-	[Object] = do(qlc:q([X || X <- mnesia:table(objects),
-		X#objects.instanceid =:= InstanceID,
-		X#objects.targetid =:= TargetID])),
-	Object.
-
-%% @doc Select all IDs.
-%% @todo This is for debug purposes only. Delete later.
-
-objects_select_all() ->
-	do(qlc:q([X || X <- mnesia:table(objects)])).
-
-%% @doc Delete all the objects for the given instance.
-
-objects_delete(InstanceID) ->
-	List = do(qlc:q([X || X <- mnesia:table(objects), X#objects.instanceid =:= InstanceID])),
-	[mnesia:transaction(fun() -> mnesia:delete({objects, ID}) end) || #objects{id=ID} <- List],
-	ok.

src/egs_user_model.erl

@@ -39,12 +39,10 @@ do(Q) ->
 %% API
 
 %% @spec start_link() -> {ok,Pid::pid()}
-%% @todo Start the cleanup timer.
 start_link() ->
 	gen_server:start_link({local, ?SERVER}, ?MODULE, [], []).
 
 %% @spec stop() -> stopped
-%% @todo Stop the cleanup timer.
 stop() ->
 	gen_server:call(?SERVER, stop).
 
@@ -103,7 +101,7 @@ handle_call({select, {neighbors, User}}, _From, State) ->
 	List = do(qlc:q([X || X <- mnesia:table(?TABLE),
 		X#?TABLE.id /= User#?TABLE.id,
 		X#?TABLE.state =:= online,
-		X#?TABLE.instanceid =:= User#?TABLE.instanceid,
+		X#?TABLE.instancepid =:= User#?TABLE.instancepid,
 		X#?TABLE.area =:= User#?TABLE.area
 	])),
 	{reply, {ok, List}, State};

src/psu/psu_game.erl

@@ -23,6 +23,7 @@
 
 -include("include/records.hrl").
 -include("include/maps.hrl").
+-include("include/missions.hrl").
 
 -define(OPTIONS, [binary, {active, false}, {certfile, "priv/ssl/servercert.pem"}, {keyfile, "priv/ssl/serverkey.pem"}, {password, "alpha"}]).
 
@@ -35,6 +36,7 @@ start_link(Port) ->
 
 %% @spec cleanup(Pid) -> ok
 %% @doc Cleanup the data associated with the failing process.
+%% @todo Cleanup the instance process if there's nobody in it anymore.
 cleanup(Pid) ->
 	case egs_user_model:read({pid, Pid}) of
 		{ok, User} ->
@@ -314,20 +316,20 @@ area_get_season(QuestID) ->
 area_load(QuestID, ZoneID, MapID, EntryID) ->
 	{ok, OldUser} = egs_user_model:read(get(gid)),
 	[{type, AreaType}, {file, QuestFile}|StartInfo] = proplists:get_value(QuestID, ?QUESTS, [{type, undefined}, {file, undefined}]),
-	[IsStart, InstanceID, RealZoneID, RealMapID, RealEntryID] = case AreaType of
+	[IsStart, RealZoneID, RealMapID, RealEntryID] = case AreaType of
 		mission ->
 			if	ZoneID =:= 65535 ->
 					[{start, [TmpZoneID, TmpMapID, TmpEntryID]}] = StartInfo,
-					[true, OldUser#egs_user_model.id, TmpZoneID, TmpMapID, TmpEntryID];
+					[true, TmpZoneID, TmpMapID, TmpEntryID];
-				true -> [false, OldUser#egs_user_model.id, ZoneID, MapID, EntryID]
+				true -> [false, ZoneID, MapID, EntryID]
 			end;
 		myroom ->
 			if	ZoneID =:= 0 ->
-					[false, undefined, 0, 423, EntryID];
+					[false, 0, 423, EntryID];
-				true -> [false, undefined, ZoneID, MapID, EntryID]
+				true -> [false, ZoneID, MapID, EntryID]
 			end;
 		_ ->
-			[false, undefined, ZoneID, MapID, EntryID]
+			[false, ZoneID, MapID, EntryID]
 	end,
 	[{file, ZoneFile}] = proplists:get_value([QuestID, RealZoneID], ?ZONES, [{file, undefined}]),
 	if	AreaType =:= myroom ->
@@ -335,14 +337,16 @@ area_load(QuestID, ZoneID, MapID, EntryID) ->
 		true ->
 			[{name, AreaName}] = proplists:get_value([QuestID, RealMapID], ?MAPS, [{name, "dammy"}])
 	end,
-	User = OldUser#egs_user_model{instanceid=InstanceID, areatype=AreaType, area={psu_area, QuestID, RealZoneID, RealMapID}, entryid=RealEntryID},
-	egs_user_model:write(User),
 	%% @todo Don't recalculate SetID when leaving the mission and back (this changes the spawns).
 	SetID = if IsStart =:= true -> crypto:rand_uniform(0, 4); true -> 0 end,
-	if	IsStart =:= true -> % initialize the mission
+	InstancePid = if IsStart =:= true -> % initialize the mission
-			psu_missions:start(InstanceID, QuestID, SetID);
+			Zones = proplists:get_value(QuestID, ?MISSIONS),
-		true -> ignore
+			{ok, RetPid} = psu_instance:start_link(Zones),
+			RetPid;
+		true -> OldUser#egs_user_model.instancepid
 	end,
+	User = OldUser#egs_user_model{instancepid=InstancePid, areatype=AreaType, area={psu_area, QuestID, RealZoneID, RealMapID}, entryid=RealEntryID},
+	egs_user_model:write(User),
 	area_load(AreaType, IsStart, SetID, OldUser, User, QuestFile, ZoneFile, AreaName).
 
 area_load(AreaType, IsStart, SetID, OldUser, User, QuestFile, ZoneFile, AreaName) ->
@@ -702,7 +706,7 @@ handle(16#0402, Data) ->
 		7 -> % spawn cleared @todo 1201 sent back with same values apparently, but not always
 			log("cleared spawn ~b", [SpawnID]),
 			{ok, User} = egs_user_model:read(get(gid)),
-			[EventID, BlockID] = psu_missions:spawn_cleared(User#egs_user_model.instanceid, SpawnID),
+			{BlockID, EventID} = psu_instance:spawn_cleared_event(User#egs_user_model.instancepid, (User#egs_user_model.area)#psu_area.zoneid, SpawnID),
 			if	EventID =:= false -> ignore;
 				true -> send_1205(EventID, BlockID, 0)
 			end;
@@ -781,7 +785,7 @@ handle(16#0c0e, _) ->
 	send_1006(11),
 	{ok, User} = egs_user_model:read(get(gid)),
 	%% delete the mission
-	psu_missions:stop(User#egs_user_model.instanceid),
+	psu_instance:stop(User#egs_user_model.instancepid),
 	%% full hp
 	Character = User#egs_user_model.character,
 	MaxHP = Character#characters.maxhp,
@@ -843,8 +847,8 @@ handle(16#0f0a, Data) ->
 	case Action of
 		0 -> % warp
 			{ok, User} = egs_user_model:read(get(gid)),
-			{X, Y, Z, Dir} = psu_missions:warp_event(User#egs_user_model.instanceid, BlockID, ListNb, ObjectNb),
+			Pos = psu_instance:warp_event(User#egs_user_model.instancepid, (User#egs_user_model.area)#psu_area.zoneid, BlockID, ListNb, ObjectNb),
-			NewUser = User#egs_user_model{pos=#pos{x=X, y=Y, z=Z, dir=Dir}},
+			NewUser = User#egs_user_model{pos=Pos},
 			egs_user_model:write(NewUser),
 			send_0503(User#egs_user_model.pos),
 			send_1211(A, C, B, 0);
@@ -866,7 +870,7 @@ handle(16#0f0a, Data) ->
 			ignore;
 		12 -> % pick/use key
 			{ok, User} = egs_user_model:read(get(gid)),
-			[[EventID|_], BlockID] = psu_missions:key_event(User#egs_user_model.instanceid, ObjectID),
+			{BlockID, [EventID|_]} = psu_instance:key_event(User#egs_user_model.instancepid, (User#egs_user_model.area)#psu_area.zoneid, ObjectID),
 			send_1205(EventID, BlockID, 0),
 			send_1213(ObjectID, 1);
 		13 -> % floor_button on (also sent when clearing a few of the rooms in black nest)
@@ -881,11 +885,11 @@ handle(16#0f0a, Data) ->
 			ignore;
 		23 -> % initialize key slots (called when picking a key or checking the gate directly with no key)
 			{ok, User} = egs_user_model:read(get(gid)),
-			[[_, EventID, _], BlockID] = psu_missions:key_event(User#egs_user_model.instanceid, ObjectID),
+			{BlockID, [_, EventID, _]} = psu_instance:key_event(User#egs_user_model.instancepid, (User#egs_user_model.area)#psu_area.zoneid, ObjectID),
 			send_1205(EventID, BlockID, 0); % in block 1, 202 = key [1] x1, 203 = key [-] x1
 		24 -> % open gate (only when client has key)
 			{ok, User} = egs_user_model:read(get(gid)),
-			[[_, _, EventID], BlockID] = psu_missions:key_event(User#egs_user_model.instanceid, ObjectID),
+			{BlockID, [_, _, EventID]} = psu_instance:key_event(User#egs_user_model.instancepid, (User#egs_user_model.area)#psu_area.zoneid, ObjectID),
 			send_1205(EventID, BlockID, 0),
 			send_1213(ObjectID, 1);
 		25 -> % sit on chair
@@ -1006,7 +1010,7 @@ handle_hits(Data) ->
 	GID = get(gid),
 	{ok, User} = egs_user_model:read(GID),
 	% hit!
-	#hit_response{type=Type, user=NewUser, exp=HasEXP, damage=Damage, targethp=TargetHP, targetse=TargetSE, events=Events} = psu_missions:object_hit(User, SourceID, TargetID),
+	#hit_response{type=Type, user=NewUser, exp=HasEXP, damage=Damage, targethp=TargetHP, targetse=TargetSE, events=Events} = psu_instance:hit(User, SourceID, TargetID),
 	case Type of
 		box ->
 			% TODO: also has a hit sent, we should send it too
@@ -1042,7 +1046,7 @@ handle_events([]) ->
 handle_events([{explode, ObjectID}|Tail]) ->
 	send_1213(ObjectID, 3),
 	handle_events(Tail);
-handle_events([{event, [EventID, BlockID]}|Tail]) ->
+handle_events([{event, [BlockID, EventID]}|Tail]) ->
 	send_1205(EventID, BlockID, 0),
 	handle_events(Tail).
 

src/psu/psu_instance.erl

@@ -0,0 +1,239 @@
+%% @author Loïc Hoguin <essen@dev-extend.eu>
+%% @copyright 2010 Loïc Hoguin.
+%% @doc Handle instances, their objects and their events.
+%%
+%%	This file is part of EGS.
+%%
+%%	EGS is free software: you can redistribute it and/or modify
+%%	it under the terms of the GNU General Public License as published by
+%%	the Free Software Foundation, either version 3 of the License, or
+%%	(at your option) any later version.
+%%
+%%	EGS is distributed in the hope that it will be useful,
+%%	but WITHOUT ANY WARRANTY; without even the implied warranty of
+%%	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+%%	GNU General Public License for more details.
+%%
+%%	You should have received a copy of the GNU General Public License
+%%	along with EGS.  If not, see <http://www.gnu.org/licenses/>.
+
+-module(psu_instance).
+-behavior(gen_server).
+
+-export([start_link/1, stop/1, key_event/3, spawn_cleared_event/3, warp_event/5, hit/3]). %% API.
+-export([init/1, handle_call/3, handle_cast/2, handle_info/2, terminate/2, code_change/3]). %% gen_server.
+
+-include_lib("stdlib/include/qlc.hrl").
+-include("include/records.hrl").
+
+%% @spec do(Q) -> Record
+%% @doc Perform a mnesia transaction using a QLC query.
+do(Q) ->
+	F = fun() -> qlc:e(Q) end,
+	{atomic, Val} = mnesia:transaction(F),
+	Val.
+
+%% API.
+
+%% @spec start_link() -> {ok,Pid::pid()}
+start_link(Zones) ->
+	gen_server:start_link(?MODULE, [Zones], []).
+
+%% @spec stop() -> stopped
+stop(InstancePid) ->
+	gen_server:call(InstancePid, stop).
+
+%% @todo @spec event(ServerPid, ObjectID, Args) -> Response
+key_event(InstancePid, ZoneID, ObjectID) ->
+	gen_server:call(InstancePid, {key_event, ZoneID, ObjectID}).
+
+spawn_cleared_event(InstancePid, ZoneID, SpawnID) ->
+	gen_server:call(InstancePid, {spawn_cleared_event, ZoneID, SpawnID}).
+
+warp_event(InstancePid, ZoneID, BlockID, ListIndex, ObjectIndex) ->
+	gen_server:call(InstancePid, {warp_event, ZoneID, BlockID, ListIndex, ObjectIndex}).
+
+%% @todo @spec hit(ServerPid, TargetID, Args) -> Response
+hit(User, SourceID, TargetID) ->
+	gen_server:call(User#egs_user_model.instancepid, {hit, (User#egs_user_model.area)#psu_area.zoneid, User, SourceID, TargetID}).
+
+%% gen_server.
+
+init([Zones]) ->
+	[map_init(Maps, ZoneID, 0, 0, 1024) || {ZoneID, Maps} <- Zones],
+	{ok, undefined}.
+
+map_init(undefined, _ZoneID, _BlockID, _ObjectID, _TargetID) ->
+	ignore; %% @todo Temporary clause until everything works fine.
+map_init([], _ZoneID, _BlockID, _ObjectID, _TargetID) ->
+	ok;
+map_init([{_MapID, ObjectLists}|Tail], ZoneID, BlockID, ObjectID, TargetID) ->
+	{ok, NextObjectID, NextTargetID} = list_init(ObjectLists, ZoneID, BlockID, ObjectID, TargetID, 0),
+	map_init(Tail, ZoneID, BlockID + 1, NextObjectID, NextTargetID).
+
+list_init([], _ZoneID, _BlockID, ObjectID, TargetID, _ListIndex) ->
+	{ok, ObjectID, TargetID};
+list_init([Objects|Tail], ZoneID, BlockID, ObjectID, TargetID, ListIndex) ->
+	{ok, NextObjectID, NextTargetID} = object_init(Objects, ZoneID, BlockID, ObjectID, TargetID, ListIndex, 0),
+	list_init(Tail, ZoneID, BlockID, NextObjectID, NextTargetID, ListIndex + 1).
+
+object_init([], _ZoneID, _BlockID, ObjectID, TargetID, _ListIndex, _ObjectIndex) ->
+	{ok, ObjectID, TargetID};
+
+%% @doc box: {InstancePid, ZoneID, TargetID}
+object_init([{box, _Model, Breakable, TrigEventID}|Tail], ZoneID, BlockID, ObjectID, TargetID, ListIndex, ObjectIndex) ->
+	case Breakable of
+		false -> ignore;
+		true -> object_insert(#psu_object{id={self(), ZoneID, TargetID}, instancepid=self(), type=box, args={BlockID, ObjectID, TrigEventID}})
+	end,
+	object_init(Tail, ZoneID, BlockID, ObjectID + 1, TargetID + 1, ListIndex, ObjectIndex + 1);
+
+%% @doc key: {InstancePid, ZoneID, key, ObjectID}
+object_init([{key, _KeySet, TrigEventID, _ReqEventID}|Tail], ZoneID, BlockID, ObjectID, TargetID, ListIndex, ObjectIndex) ->
+	object_insert(#psu_object{id={self(), ZoneID, key, ObjectID}, instancepid=self(), type=key, args={BlockID, [TrigEventID]}}),
+	object_init(Tail, ZoneID, BlockID, ObjectID + 1, TargetID, ListIndex, ObjectIndex + 1);
+
+%% @doc key_console: @see key; @todo handled the same for now
+object_init([{key_console, KeySet, TrigEventID, _ReqEventID}|Tail], ZoneID, BlockID, ObjectID, TargetID, ListIndex, ObjectIndex) ->
+	object_insert(#psu_object{id={self(), ZoneID, key, ObjectID}, instancepid=self(), type=key_console, args={BlockID, [243 + KeySet, 201 + KeySet, TrigEventID]}}),
+	object_init(Tail, ZoneID, BlockID, ObjectID + 1, TargetID, ListIndex, ObjectIndex + 1);
+
+%% @doc spawn: {InstancePid, ZoneID, 'spawn', SpawnID}
+%% @todo save enemies individually, do something, etc.
+%% @todo temporarily save the spawn to handle events properly
+object_init([{'spawn', NbTargets, TrigEventID, _ReqEventID}|Tail], ZoneID, BlockID, ObjectID, TargetID, ListIndex, ObjectIndex) ->
+	object_insert(#psu_object{id={self(), ZoneID, 'spawn', TargetID - 1024}, instancepid=self(), type='spawn', args={BlockID, TrigEventID}}),
+	object_init(Tail, ZoneID, BlockID, ObjectID + 1, TargetID + NbTargets, ListIndex, ObjectIndex + 1);
+
+%% @doc warp: {InstancePid, ZoneID, warp, BlockID, ListIndex, ObjectIndex}
+object_init([{warp, DestX, DestY, DestZ, DestDir}|Tail], ZoneID, BlockID, ObjectID, TargetID, ListIndex, ObjectIndex) ->
+	object_insert(#psu_object{id={self(), ZoneID, warp, BlockID, ListIndex, ObjectIndex}, instancepid=self(), type=warp, args=#pos{x=DestX, y=DestY, z=DestZ, dir=DestDir}}),
+	object_init(Tail, ZoneID, BlockID, ObjectID, TargetID, ListIndex, ObjectIndex + 1);
+
+%% @doc Ignore for now: crystal
+%% @todo Probably have 2 TargetID because of its on/off state.
+object_init([crystal|Tail], ZoneID, BlockID, ObjectID, TargetID, ListIndex, ObjectIndex) ->
+	object_init(Tail, ZoneID, BlockID, ObjectID + 1, TargetID + 2, ListIndex, ObjectIndex + 1);
+
+%% @doc Ignore for now: floor_button, shoot_button, google_target, trap (all kinds)
+object_init([Object|Tail], ZoneID, BlockID, ObjectID, TargetID, ListIndex, ObjectIndex)
+	when	Object =:= floor_button;
+			Object =:= shoot_button;
+			Object =:= google_target;
+			Object =:= trap ->
+	object_init(Tail, ZoneID, BlockID, ObjectID + 1, TargetID + 1, ListIndex, ObjectIndex + 1);
+
+%% @doc Ignore for now: objects without any ObjectID or TargetID.
+object_init([Object|Tail], ZoneID, BlockID, ObjectID, TargetID, ListIndex, ObjectIndex)
+	when	Object =:= static_model;
+			Object =:= invisible_block;
+			Object =:= entrance;
+			Object =:= 'exit';
+			Object =:= label;
+			Object =:= hidden_minimap_section;
+			Object =:= fog;
+			Object =:= pp_cube;
+			Object =:= healing_pad ->
+	object_init(Tail, ZoneID, BlockID, ObjectID, TargetID, ListIndex, ObjectIndex + 1);
+
+%% @doc Ignore everything else for now: objects with an ObjectID but without a TargetID.
+object_init([_Object|Tail], ZoneID, BlockID, ObjectID, TargetID, ListIndex, ObjectIndex) ->
+	object_init(Tail, ZoneID, BlockID, ObjectID + 1, TargetID, ListIndex, ObjectIndex + 1).
+
+%% Event handlers
+
+handle_call({key_event, ZoneID, ObjectID}, _From, State) ->
+	#psu_object{args=Args} = object_select({self(), ZoneID, key, ObjectID}),
+	{reply, Args, State};
+
+handle_call({spawn_cleared_event, ZoneID, SpawnID}, _From, State) ->
+	#psu_object{args=Args} = object_select({self(), ZoneID, 'spawn', SpawnID}),
+	{reply, Args, State};
+
+handle_call({warp_event, ZoneID, BlockID, ListIndex, ObjectIndex}, _From, State) ->
+	#psu_object{args=Args} = object_select({self(), ZoneID, warp, BlockID, ListIndex, ObjectIndex}),
+	{reply, Args, State};
+
+%% Hit handler
+
+%% @todo Handle everything correctly.
+handle_call({hit, ZoneID, User, _SourceID, TargetID}, _From, State) ->
+	try
+		Box = object_select({self(), ZoneID, TargetID}),
+		BoxReply = box_hit(Box),
+		{reply, BoxReply, State}
+	catch _:_ ->
+		OtherReply = if TargetID =:= 0 ->
+					player_hit(User);
+			true -> enemy_hit(User)
+		end,
+		{reply, OtherReply, State}
+	end;
+
+%% @doc Remove all objects from the database when the process is stopped.
+handle_call(stop, _From, State) ->
+	List = do(qlc:q([X || X <- mnesia:table(psu_object), X#psu_object.instancepid =:= self()])),
+	[mnesia:transaction(fun() -> mnesia:delete({psu_object, ID}) end) || #psu_object{id=ID} <- List],
+	{stop, normal, stopped, State};
+
+handle_call(_Request, _From, State) ->
+	{reply, ignored, State}.
+
+handle_cast(_Msg, State) ->
+	{noreply, State}.
+
+handle_info(_Info, State) ->
+	{noreply, State}.
+
+terminate(_Reason, _State) ->
+	ok.
+
+code_change(_OldVsn, State, _Extra) ->
+	{ok, State}.
+
+%% Internal functions
+
+%% @todo doc
+object_insert(Object) ->
+	mnesia:transaction(fun() -> mnesia:write(Object) end).
+
+%% @todo doc
+object_select(ID) ->
+	case mnesia:transaction(fun() -> mnesia:read({psu_object, ID}) end) of
+		{atomic, []} -> undefined;
+		{atomic, [Val]} -> Val
+	end.
+
+box_hit(#psu_object{args={BlockID, ObjectID, TrigEventID}}) ->
+	Events =
+		if	TrigEventID =:= false -> [{explode, ObjectID}];
+			true -> [{explode, ObjectID}, {event, [BlockID, TrigEventID]}]
+		end,
+	#hit_response{type=box, events=Events}.
+
+enemy_hit(User) ->
+	Damage = 1,
+	IncEXP = 1,
+	Character = User#egs_user_model.character,
+	Level = Character#characters.mainlevel,
+	NewEXP = Level#level.exp + IncEXP,
+	NewLevel = Level#level{exp=NewEXP},
+	NewCharacter = Character#characters{mainlevel=NewLevel},
+	NewUser = User#egs_user_model{character=NewCharacter},
+	% todo delete the enemy from the db when it dies
+	#hit_response{type=enemy, user=NewUser, exp=true, damage=Damage, targethp=0, targetse=[death]}.
+
+player_hit(User) ->
+	Damage = 10,
+	Character = User#egs_user_model.character,
+	TmpHP = Character#characters.currenthp - Damage,
+	if	TmpHP =< 0 ->
+			NewHP = 0,
+			SE = [flinch, death];
+		true ->
+			NewHP = TmpHP,
+			SE = [flinch]
+	end,
+	NewCharacter = Character#characters{currenthp=NewHP},
+	NewUser = User#egs_user_model{character=NewCharacter},
+	#hit_response{type=player, user=NewUser, damage=Damage, targethp=NewHP, targetse=SE}.

src/psu_missions.erl

@@ -1,169 +0,0 @@
-%	EGS: Erlang Game Server
-%	Copyright (C) 2010  Loic Hoguin
-%
-%	This file is part of EGS.
-%
-%	EGS is free software: you can redistribute it and/or modify
-%	it under the terms of the GNU General Public License as published by
-%	the Free Software Foundation, either version 3 of the License, or
-%	(at your option) any later version.
-%
-%	EGS is distributed in the hope that it will be useful,
-%	but WITHOUT ANY WARRANTY; without even the implied warranty of
-%	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-%	GNU General Public License for more details.
-%
-%	You should have received a copy of the GNU General Public License
-%	along with EGS.  If not, see <http://www.gnu.org/licenses/>.
-
--module(psu_missions).
--export([
-	start/3, stop/1, key_event/2, warp_event/4, object_hit/3, spawn_cleared/2
-]).
-
--include("include/missions.hrl").
--include("include/records.hrl").
-
-start(InstanceID, QuestID, _SetID) ->
-	MapList = proplists:get_value(QuestID, ?MISSIONS),
-	map_init(InstanceID, MapList, 0, 0, 1024).
-
-map_init(_InstanceID, undefined, _BlockID, _ObjectID, _TargetID) ->
-	ignore; %% @todo Temporary clause until everything works fine.
-map_init(_InstanceID, [], _BlockID, _ObjectID, _TargetID) ->
-	ok;
-map_init(InstanceID, [Map|Tail], BlockID, ObjectID, TargetID) ->
-	{_MapID, Objects} = Map,
-	{ok, NewObjectID, NewTargetID} = list_init(InstanceID, BlockID, Objects, 0, ObjectID, TargetID),
-	map_init(InstanceID, Tail, BlockID + 1, NewObjectID, NewTargetID).
-
-list_init(_InstanceID, _BlockID, [], _ListNb, ObjectID, TargetID) ->
-	{ok, ObjectID, TargetID};
-list_init(InstanceID, BlockID, [Objects|Tail], ListNb, ObjectID, TargetID) ->
-	{ok, NewObjectID, NewTargetID} = object_init(InstanceID, BlockID, Objects, ListNb, 0, ObjectID, TargetID),
-	list_init(InstanceID, BlockID, Tail, ListNb + 1, NewObjectID, NewTargetID).
-
-object_init(_InstanceID, _BlockID, [], _ListNb, _ObjectNb, ObjectID, TargetID) ->
-	{ok, ObjectID, TargetID};
-object_init(InstanceID, BlockID, [{box, _Model, Breakable, TrigEventID}|Tail], ListNb, ObjectNb, ObjectID, TargetID) ->
-	case Breakable of
-		false -> ignore;
-		true ->
-			egs_db:objects_insert(#objects{id=[InstanceID, ObjectID], instanceid=InstanceID, objectid=ObjectID, type=box, targetid=TargetID, blockid=BlockID, triggereventid=TrigEventID})
-	end,
-	object_init(InstanceID, BlockID, Tail, ListNb, ObjectNb + 1, ObjectID + 1, TargetID + 1);
-%% @todo Apparently floor_button has a TargetID. Not sure why yet. Just increment the value.
-object_init(InstanceID, BlockID, [floor_button|Tail], ListNb, ObjectNb, ObjectID, TargetID) ->
-	object_init(InstanceID, BlockID, Tail, ListNb, ObjectNb + 1, ObjectID + 1, TargetID + 1);
-%% @todo Apparently shoot_button has a TargetID. I'm sure why though.
-object_init(InstanceID, BlockID, [shoot_button|Tail], ListNb, ObjectNb, ObjectID, TargetID) ->
-	object_init(InstanceID, BlockID, Tail, ListNb, ObjectNb + 1, ObjectID + 1, TargetID + 1);
-%% @todo Goggle targets have a targetid.
-object_init(InstanceID, BlockID, [goggle_target|Tail], ListNb, ObjectNb, ObjectID, TargetID) ->
-	object_init(InstanceID, BlockID, Tail, ListNb, ObjectNb + 1, ObjectID + 1, TargetID + 1);
-%% @todo All kinds of traps have a TargetID, even if they're not targettable.
-object_init(InstanceID, BlockID, [trap|Tail], ListNb, ObjectNb, ObjectID, TargetID) ->
-	object_init(InstanceID, BlockID, Tail, ListNb, ObjectNb + 1, ObjectID + 1, TargetID + 1);
-%% @todo Not sure why but it works that way in True Darkness.
-object_init(InstanceID, BlockID, [boss_gate|Tail], ListNb, ObjectNb, ObjectID, TargetID) ->
-	object_init(InstanceID, BlockID, Tail, ListNb, ObjectNb + 1, ObjectID + 1, TargetID + 1);
-%% @todo key and key_console event handling will have to be fixed.
-object_init(InstanceID, BlockID, [{key, _KeySet, TrigEventID, _ReqEventID}|Tail], ListNb, ObjectNb, ObjectID, TargetID) ->
-	egs_db:objects_insert(#objects{id=[InstanceID, {key, ObjectID}], instanceid=InstanceID, objectid=ObjectID, type=key, blockid=BlockID, triggereventid=[TrigEventID]}),
-	object_init(InstanceID, BlockID, Tail, ListNb, ObjectNb + 1, ObjectID + 1, TargetID);
-%% @todo Maybe separate key from key_console in its handling?
-object_init(InstanceID, BlockID, [{key_console, KeySet, _ReqKeyEventsID, TrigEventID}|Tail], ListNb, ObjectNb, ObjectID, TargetID) ->
-	egs_db:objects_insert(#objects{id=[InstanceID, {key, ObjectID}], instanceid=InstanceID, objectid=ObjectID, type=key, blockid=BlockID, triggereventid=[243 + KeySet, 201 + KeySet, TrigEventID]}),
-	object_init(InstanceID, BlockID, Tail, ListNb, ObjectNb + 1, ObjectID + 1, TargetID);
-%% @todo save enemies individually, do something, etc.
-%% @todo temporarily save the spawn to handle events properly
-object_init(InstanceID, BlockID, [{'spawn', NbTargets, TrigEventID, _ReqEventID}|Tail], ListNb, ObjectNb, ObjectID, TargetID) ->
-	egs_db:objects_insert(#objects{id=[InstanceID, {'spawn', TargetID - 1024}], instanceid=InstanceID, type='spawn', blockid=BlockID, triggereventid=TrigEventID}),
-	object_init(InstanceID, BlockID, Tail, ListNb, ObjectNb + 1, ObjectID + 1, TargetID + NbTargets);
-object_init(InstanceID, BlockID, [{warp, DestX, DestY, DestZ, DestDir}|Tail], ListNb, ObjectNb, ObjectID, TargetID) ->
-	egs_db:objects_insert(#objects{id=[InstanceID, {warp, BlockID, ListNb, ObjectNb}], instanceid=InstanceID, type=warp, blockid=BlockID, args={DestX, DestY, DestZ, DestDir}}),
-	object_init(InstanceID, BlockID, Tail, ListNb, ObjectNb + 1, ObjectID, TargetID);
-%% @todo Apparently crystal has 2 TargetIDs. Presumably because it has both on/off states.
-object_init(InstanceID, BlockID, [crystal|Tail], ListNb, ObjectNb, ObjectID, TargetID) ->
-	object_init(InstanceID, BlockID, Tail, ListNb, ObjectNb + 1, ObjectID + 1, TargetID + 2);
-%% A few object types don't have an ObjectID nor a TargetID. Disregard them completely.
-object_init(InstanceID, BlockID, [ObjType|Tail], ListNb, ObjectNb, ObjectID, TargetID)
-	when	ObjType =:= static_model;
-			ObjType =:= invisible_block;
-			ObjType =:= entrance;
-			ObjType =:= 'exit';
-			ObjType =:= label;
-			ObjType =:= hidden_minimap_section;
-			ObjType =:= fog;
-			ObjType =:= pp_cube;
-			ObjType =:= healing_pad ->
-	object_init(InstanceID, BlockID, Tail, ListNb, ObjectNb + 1, ObjectID, TargetID);
-%% Others are normal objects, we don't handle them but they have an ObjectID.
-object_init(InstanceID, BlockID, [_|Tail], ListNb, ObjectNb, ObjectID, TargetID) ->
-	object_init(InstanceID, BlockID, Tail, ListNb, ObjectNb + 1, ObjectID + 1, TargetID).
-
-stop(InstanceID) ->
-	egs_db:objects_delete(InstanceID).
-
-key_event(InstanceID, ObjectID) ->
-	#objects{triggereventid=EventID, blockid=BlockID} = egs_db:objects_select([InstanceID, {key, ObjectID}]),
-	[EventID, BlockID].
-
-warp_event(InstanceID, BlockID, ListNb, ObjectNb) ->
-	#objects{args=Args} = egs_db:objects_select([InstanceID, {warp, BlockID, ListNb, ObjectNb}]),
-	Args.
-
-object_hit(User, _SourceID, TargetID) ->
-	try
-		Object = egs_db:objects_select_by_targetid(User#egs_user_model.instanceid, TargetID),
-		if	Object#objects.type =:= box ->
-				box_hit(User, Object);
-			true ->
-				io:format("unknown object hit~n")
-		end
-	catch _:_ ->
-		if	TargetID =:= 0 ->
-				player_hit(User);
-			true ->
-				enemy_hit(User)
-		end
-	end.
-
-box_hit(User, Box) ->
-	% todo delete the box from the db
-	EventsResponse =
-		if	Box#objects.triggereventid =:= false -> [{explode, Box#objects.objectid}];
-			true -> [{explode, Box#objects.objectid}, {event, [Box#objects.triggereventid, Box#objects.blockid]}]
-		end,
-	#hit_response{type=box, user=User, events=EventsResponse}.
-
-enemy_hit(User) ->
-	Damage = 1,
-	IncEXP = 1,
-	Character = User#egs_user_model.character,
-	Level = Character#characters.mainlevel,
-	NewEXP = Level#level.exp + IncEXP,
-	NewLevel = Level#level{exp=NewEXP},
-	NewCharacter = Character#characters{mainlevel=NewLevel},
-	NewUser = User#egs_user_model{character=NewCharacter},
-	% todo delete the enemy from the db when it dies
-	#hit_response{type=enemy, user=NewUser, exp=true, damage=Damage, targethp=0, targetse=[death]}.
-
-player_hit(User) ->
-	Damage = 10,
-	Character = User#egs_user_model.character,
-	TmpHP = Character#characters.currenthp - Damage,
-	if	TmpHP =< 0 ->
-			NewHP = 0,
-			SE = [flinch, death];
-		true ->
-			NewHP = TmpHP,
-			SE = [flinch]
-	end,
-	NewCharacter = Character#characters{currenthp=NewHP},
-	NewUser = User#egs_user_model{character=NewCharacter},
-	#hit_response{type=player, user=NewUser, damage=Damage, targethp=NewHP, targetse=SE}.
-
-spawn_cleared(InstanceID, SpawnID) ->
-	#objects{triggereventid=EventID, blockid=BlockID} = egs_db:objects_select([InstanceID, {'spawn', SpawnID}]),
-	[EventID, BlockID].

src/psu_parser.erl

@@ -45,7 +45,7 @@ parse_zone(QuestID, NblFilename) ->
 	log("header: end ptr(~b) areaid list ptr(~b)", [EndRelPtr, AreaIDListRelPtr]),
 	{ok, _AreaCode, NbMaps, MapsListPtr} = parse_areaid_list(Data, AreaIDListRelPtr - 16),
 	MapList = parse_mapnumbers_list(Data, NbMaps, MapsListPtr - BasePtr - 16),
-	ObjList = {QuestID, [{MapID, parse_object_list_headers(BasePtr, Data, NbHeaders, ObjListHeadersPtr - BasePtr - 16)} || {MapID, NbHeaders, ObjListHeadersPtr} <- MapList]},
+	ObjList = {QuestID, [{0, [{MapID, parse_object_list_headers(BasePtr, Data, NbHeaders, ObjListHeadersPtr - BasePtr - 16)} || {MapID, NbHeaders, ObjListHeadersPtr} <- MapList]}]},
 	nbl_cleanup(),
 	ObjList.
 
@@ -172,7 +172,7 @@ parse_object_args(22, _Params, Data) ->
 	ReqKeyEvents = [convert_eventid(RawReqKey1Event), convert_eventid(RawReqKey2Event), convert_eventid(RawReqKey3Event), convert_eventid(RawReqKey4Event)],
 	TrigEvent = convert_eventid(RawTrigEvent),
 	log("key_console: a(~b) keyset(~b) b(~b) c(~b) reqkeyevents(~p) trigevent(~p) d(~b)", [UnknownA, KeySet, UnknownB, UnknownC, ReqKeyEvents, TrigEvent, UnknownD]),
-	{key_console, KeySet, ReqKeyEvents, TrigEvent};
+	{key_console, KeySet, TrigEvent, ReqKeyEvents};
 
 %% @doc Small spawn.